zls/tests/lsp_features/references.zig
2023-03-23 15:13:14 +00:00

252 lines
8.1 KiB
Zig

const std = @import("std");
const zls = @import("zls");
const builtin = @import("builtin");
const helper = @import("../helper.zig");
const Context = @import("../context.zig").Context;
const ErrorBuilder = @import("../ErrorBuilder.zig");
const types = zls.types;
const offsets = zls.offsets;
const allocator: std.mem.Allocator = std.testing.allocator;
test "references" {
try testReferences(
\\const <0> = 0;
\\const foo = <0>;
);
try testReferences(
\\var <0> = 0;
\\var foo = <0>;
);
try testReferences(
\\const <0> = struct {};
\\var foo: <0> = <0>{};
);
try testReferences(
\\const <0> = enum {};
\\var foo: <0> = undefined;
);
try testReferences(
\\const <0> = union {};
\\var foo: <0> = <0>{};
);
try testReferences(
\\fn <0>() void {}
\\var foo = <0>();
);
try testReferences(
\\const <0> = error{};
\\fn bar() <0>!void {}
);
}
test "references - global scope" {
try testReferences(
\\const foo = <0>;
\\const <0> = 0;
\\const bar = <0>;
);
}
test "references - local scope" {
try testReferences(
\\fn foo(<0>: u32, bar: u32) void {
\\ return <0> + bar;
\\}
);
try testReferences(
\\const foo = outer: {
\\ _ = inner: {
\\ const <0> = 0;
\\ break :inner <0>;
\\ };
\\ const <1> = 0;
\\ break :outer <1>;
\\};
\\const bar = foo;
);
}
test "references - struct field access" {
if (true) return error.SkipZigTest; // TODO
try testReferences(
\\const S = struct {placeholder: u32 = 3};
\\pub fn foo() bool {
\\ const s: S = .{};
\\ return s.<0> == s.<0>;
\\}
);
}
test "references - struct decl access" {
try testReferences(
\\const S = struct {
\\ fn <0>() void {}
\\};
\\pub fn foo() bool {
\\ const s: S = .{};
\\ s.<0>();
\\ s.<0>();
\\ <1>();
\\}
\\fn <1>() void {}
);
}
test "references - while continue expression" {
try testReferences(
\\ pub fn foo() void {
\\ var <0>: u32 = 0;
\\ while (true) : (<0> += 1) {}
\\ }
);
}
test "references - test with identifier" {
try testReferences(
\\pub fn <0>() bool {}
\\test <0> {}
);
}
test "references - label" {
if (true) return error.SkipZigTest; // TODO
try testReferences(
\\const foo = <0>: {
\\ break :<0> 0;
\\};
);
}
test "references - cross-file reference" {
if (true) return error.SkipZigTest; // TODO
try testMFReferences(&.{
\\pub const <0> = struct {};
,
\\const file = @import("file_0.zig");
\\const F = file.<0>;
});
}
fn testReferences(source: []const u8) !void {
return testMFReferences(&.{source});
}
/// source files have the following name pattern: `file_{d}.zig`
fn testMFReferences(sources: []const []const u8) !void {
const placeholder_name = "placeholder";
var ctx = try Context.init();
defer ctx.deinit();
const File = struct { source: []const u8, new_source: []const u8 };
const LocPair = struct { file_index: usize, old: offsets.Loc, new: offsets.Loc };
var files = std.StringArrayHashMapUnmanaged(File){};
defer {
for (files.values()) |file| allocator.free(file.new_source);
files.deinit(allocator);
}
var loc_set: std.StringArrayHashMapUnmanaged(std.MultiArrayList(LocPair)) = .{};
defer {
for (loc_set.values()) |*locs| locs.deinit(allocator);
loc_set.deinit(allocator);
}
try files.ensureTotalCapacity(allocator, sources.len);
for (sources, 0..) |source, file_index| {
var phr = try helper.collectReplacePlaceholders(allocator, source, placeholder_name);
defer phr.deinit(allocator);
const uri = try ctx.addDocument(phr.new_source);
files.putAssumeCapacityNoClobber(uri, .{ .source = source, .new_source = phr.new_source });
phr.new_source = ""; // `files` takes ownership of `new_source` from `phr`
for (phr.locations.items(.old), phr.locations.items(.new)) |old, new| {
const name = offsets.locToSlice(source, old);
const gop = try loc_set.getOrPutValue(allocator, name, .{});
try gop.value_ptr.append(allocator, .{ .file_index = file_index, .old = old, .new = new });
}
}
var error_builder = ErrorBuilder.init(allocator);
defer error_builder.deinit();
errdefer error_builder.writeDebug();
for (files.keys(), files.values()) |file_uri, file| {
try error_builder.addFile(file_uri, file.new_source);
}
for (loc_set.values()) |locs| {
error_builder.clearMessages();
for (locs.items(.file_index), locs.items(.new)) |file_index, new_loc| {
const file = files.values()[file_index];
const file_uri = files.keys()[file_index];
const middle = new_loc.start + (new_loc.end - new_loc.start) / 2;
const response = try ctx.requestGetResponse(
?[]types.Location,
"textDocument/references",
types.ReferenceParams{
.textDocument = .{ .uri = file_uri },
.position = offsets.indexToPosition(file.new_source, middle, ctx.server.offset_encoding),
.context = .{ .includeDeclaration = true },
},
);
try error_builder.msgAtLoc("asked for references here", file_uri, new_loc, .info, .{});
const actual_locations: []const types.Location = response.result orelse {
std.debug.print("Server returned `null` as the result\n", .{});
return error.InvalidResponse;
};
// keeps track of expected locations that have been given by the server
// used to detect double references and missing references
var visited = try std.DynamicBitSetUnmanaged.initEmpty(allocator, locs.len);
defer visited.deinit(allocator);
for (actual_locations) |response_location| {
const actual_loc = offsets.rangeToLoc(file.new_source, response_location.range, ctx.server.offset_encoding);
const actual_file_index = files.getIndex(response_location.uri) orelse {
std.debug.print("received location to unknown file `{s}` as the result\n", .{response_location.uri});
return error.InvalidReference;
};
const index = found_index: {
for (locs.items(.new), locs.items(.file_index), 0..) |expected_loc, expected_file_index, idx| {
if (expected_file_index != actual_file_index) continue;
if (expected_loc.start != actual_loc.start) continue;
if (expected_loc.end != actual_loc.end) continue;
break :found_index idx;
}
try error_builder.msgAtLoc("server returned unexpected reference!", file_uri, actual_loc, .err, .{});
return error.UnexpectedReference;
};
if (visited.isSet(index)) {
try error_builder.msgAtLoc("server returned duplicate reference!", file_uri, actual_loc, .err, .{});
return error.DuplicateReference;
} else {
visited.set(index);
}
}
var has_unvisited = false;
var unvisited_it = visited.iterator(.{ .kind = .unset });
while (unvisited_it.next()) |index| {
const unvisited_file_index = locs.items(.file_index)[index];
const unvisited_uri = files.keys()[unvisited_file_index];
const unvisited_loc = locs.items(.new)[index];
try error_builder.msgAtLoc("expected reference here!", unvisited_uri, unvisited_loc, .err, .{});
has_unvisited = true;
}
if (has_unvisited) return error.ExpectedReference;
}
}
}