lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
agra
2026-02-26 00:18:36 +02:00
parent f0569a8a3e
commit 7209e8e69d
6 changed files with 299 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

361
src/lsp/server.zig
View File

@@ -230,6 +230,26 @@ pub const Server = struct {
if (try self.sendSymbolLocationWithOrigin(id_json, doc, sym, qn_origin)) return;
}
}
// Struct method/field: obj.method or Type.method or obj.field
if (try self.resolveStructMemberDef(id_json, sema, doc, qn.ns, qn.member, qn_origin)) return;
}
// 1b. Dot-shorthand: .method(args) — identifier preceded by dot with no qualifier
if (extractIdentAtOffset(doc.source, offset)) |name| {
const name_start = @as(u32, @intCast(@intFromPtr(name.ptr) - @intFromPtr(doc.source.ptr)));
if (name_start > 0 and doc.source[name_start - 1] == '.' and
(name_start < 2 or !isIdentChar(doc.source[name_start - 2])))
{
const name_end = name_start + @as(u32, @intCast(name.len));
const origin = sx.ast.Span{ .start = name_start, .end = name_end };
// Search all type declarations for a matching method/variant/field
for (sema.symbols) |sym| {
if (sym.kind != .struct_type and sym.kind != .enum_type) continue;
const lookup = self.findTypeDeclNode(sema, doc, sym.name) orelse continue;
if (try self.sendMemberLocation(id_json, lookup, name, doc, origin)) return;
}
}
}
// 2. Reference at offset → jump to definition
@@ -525,12 +545,12 @@ pub const Server = struct {
}
} else if (doc.root) |root| {
// Try as type name directly (e.g. Vec2., Color.)
try self.collectMemberCompletions(&items, sema, root, prefix);
try self.collectMemberCompletions(&items, sema, doc, prefix);
// Try as variable name — resolve to type and offer fields + UFCS methods
if (items.items.len == 0) {
if (resolveVariableType(sema, prefix)) |type_name| {
try self.collectMemberCompletions(&items, sema, root, type_name);
try self.collectMemberCompletions(&items, sema, doc, type_name);
try self.collectUfcsCompletions(&items, root, type_name);
}
}
@@ -664,7 +684,8 @@ pub const Server = struct {
const payload_type_name = if (vt.data == .type_expr) vt.data.type_expr.name else break;
// Now offer that struct's fields
const payload_sema = if (lookup_doc) |ld| ld.sema orelse sema else sema;
try self.collectMemberCompletions(items, payload_sema, root, payload_type_name);
const payload_doc = if (lookup_doc) |ld| ld else doc;
try self.collectMemberCompletions(items, payload_sema, payload_doc, payload_type_name);
return;
}
}
@@ -858,88 +879,69 @@ pub const Server = struct {
}
}
fn collectMemberCompletions(self: *Server, items: *std.ArrayList(lsp.CompletionItem), sema: SemaResult, root: *sx.ast.Node, name: []const u8) !void {
for (sema.symbols) |sym| {
if (!std.mem.eql(u8, sym.name, name)) continue;
fn collectMemberCompletions(self: *Server, items: *std.ArrayList(lsp.CompletionItem), sema: SemaResult, doc: *const Document, name: []const u8) !void {
const lookup = self.findTypeDeclNode(sema, doc, name) orelse return;
const node = lookup.node;
if (sym.kind == .struct_type) {
// For imported symbols, look up the source doc's AST
const lookup_root = if (sym.origin) |origin_path|
if (self.documents.get(origin_path)) |od| od.root orelse root else root
else
root;
if (sx.sema.findNodeAtOffset(lookup_root, sym.def_span.start)) |node| {
if (node.data == .struct_decl) {
const sd = node.data.struct_decl;
for (sd.field_names, 0..) |field_name, fi| {
const detail: ?[]const u8 = if (fi < sd.field_types.len) blk: {
const ft = sd.field_types[fi];
break :blk if (ft.data == .type_expr) ft.data.type_expr.name else null;
} else null;
if (node.data == .struct_decl) {
const sd = node.data.struct_decl;
for (sd.field_names, 0..) |field_name, fi| {
const detail: ?[]const u8 = if (fi < sd.field_types.len) blk: {
const ft = sd.field_types[fi];
break :blk if (ft.data == .type_expr) ft.data.type_expr.name else null;
} else null;
try items.append(self.allocator, .{
.label = field_name,
.kind = @intFromEnum(lsp.CompletionItemKind.Field),
.detail = detail,
});
}
}
}
} else if (sym.kind == .enum_type) {
const lookup_root = if (sym.origin) |origin_path|
if (self.documents.get(origin_path)) |od| od.root orelse root else root
else
root;
if (sx.sema.findNodeAtOffset(lookup_root, sym.def_span.start)) |node| {
if (node.data == .enum_decl) {
const ed = node.data.enum_decl;
for (ed.variant_names) |variant| {
try items.append(self.allocator, .{
.label = variant,
.kind = @intFromEnum(lsp.CompletionItemKind.EnumMember),
});
}
}
}
} else if (sym.kind == .protocol_type) {
const lookup_root = if (sym.origin) |origin_path|
if (self.documents.get(origin_path)) |od| od.root orelse root else root
else
root;
if (sx.sema.findNodeAtOffset(lookup_root, sym.def_span.start)) |node| {
if (node.data == .protocol_decl) {
const pd = node.data.protocol_decl;
for (pd.methods) |method| {
// Build detail string: (params) -> ret
var detail_buf = std.ArrayList(u8).empty;
try detail_buf.append(self.allocator, '(');
for (method.param_names, 0..) |pname, pi| {
if (pi > 0) try detail_buf.appendSlice(self.allocator, ", ");
try detail_buf.appendSlice(self.allocator, pname);
if (pi < method.params.len) {
try detail_buf.appendSlice(self.allocator, ": ");
if (method.params[pi].data == .type_expr) {
try detail_buf.appendSlice(self.allocator, method.params[pi].data.type_expr.name);
}
}
}
try detail_buf.append(self.allocator, ')');
if (method.return_type) |rt| {
try detail_buf.appendSlice(self.allocator, " -> ");
if (rt.data == .type_expr) {
try detail_buf.appendSlice(self.allocator, rt.data.type_expr.name);
}
}
try items.append(self.allocator, .{
.label = method.name,
.kind = @intFromEnum(lsp.CompletionItemKind.Method),
.detail = detail_buf.items,
});
}
}
try items.append(self.allocator, .{
.label = field_name,
.kind = @intFromEnum(lsp.CompletionItemKind.Field),
.detail = detail,
});
}
for (sd.methods) |method_node| {
if (method_node.data == .fn_decl) {
try items.append(self.allocator, .{
.label = method_node.data.fn_decl.name,
.kind = @intFromEnum(lsp.CompletionItemKind.Method),
});
}
}
break;
} else if (node.data == .enum_decl) {
const ed = node.data.enum_decl;
for (ed.variant_names) |variant| {
try items.append(self.allocator, .{
.label = variant,
.kind = @intFromEnum(lsp.CompletionItemKind.EnumMember),
});
}
} else if (node.data == .protocol_decl) {
const pd = node.data.protocol_decl;
for (pd.methods) |method| {
// Build detail string: (params) -> ret
var detail_buf = std.ArrayList(u8).empty;
try detail_buf.append(self.allocator, '(');
for (method.param_names, 0..) |pname, pi| {
if (pi > 0) try detail_buf.appendSlice(self.allocator, ", ");
try detail_buf.appendSlice(self.allocator, pname);
if (pi < method.params.len) {
try detail_buf.appendSlice(self.allocator, ": ");
if (method.params[pi].data == .type_expr) {
try detail_buf.appendSlice(self.allocator, method.params[pi].data.type_expr.name);
}
}
}
try detail_buf.append(self.allocator, ')');
if (method.return_type) |rt| {
try detail_buf.appendSlice(self.allocator, " -> ");
if (rt.data == .type_expr) {
try detail_buf.appendSlice(self.allocator, rt.data.type_expr.name);
}
}
try items.append(self.allocator, .{
.label = method.name,
.kind = @intFromEnum(lsp.CompletionItemKind.Method),
.detail = detail_buf.items,
});
}
}
}
@@ -1806,6 +1808,89 @@ pub const Server = struct {
return doc;
}
const TypeDeclLookup = struct { node: *sx.ast.Node, doc: *const Document };
/// Given a type name, find its AST declaration node and the document it lives in.
/// Works for struct_decl, enum_decl, union_decl, and protocol_decl across files.
fn findTypeDeclNode(self: *Server, sema: SemaResult, doc: *const Document, type_name: []const u8) ?TypeDeclLookup {
for (sema.symbols) |sym| {
if (!std.mem.eql(u8, sym.name, type_name)) continue;
if (sym.kind != .struct_type and sym.kind != .enum_type and sym.kind != .protocol_type) continue;
const lookup_doc = self.resolveSymbolDoc(doc, sym);
const lookup_root = lookup_doc.root orelse return null;
if (sx.sema.findNodeAtOffset(lookup_root, sym.def_span.start)) |node| {
return .{ .node = node, .doc = lookup_doc };
}
return null;
}
return null;
}
/// Send a go-to-definition response for a struct method, field, or enum variant.
fn sendMemberLocation(self: *Server, id_json: []const u8, lookup: TypeDeclLookup, member_name: []const u8, origin_doc: *const Document, origin: sx.ast.Span) !bool {
if (lookup.node.data == .struct_decl) {
const sd = lookup.node.data.struct_decl;
// Check methods
for (sd.methods) |method_node| {
if (method_node.data == .fn_decl) {
if (std.mem.eql(u8, method_node.data.fn_decl.name, member_name)) {
return self.sendSpanLocation(id_json, lookup.doc, method_node.span, origin_doc, origin);
}
}
}
// Check fields — use field type span as approximate location
for (sd.field_names, 0..) |fname, fi| {
if (std.mem.eql(u8, fname, member_name)) {
if (fi < sd.field_types.len) {
return self.sendSpanLocation(id_json, lookup.doc, sd.field_types[fi].span, origin_doc, origin);
}
}
}
} else if (lookup.node.data == .enum_decl) {
const ed = lookup.node.data.enum_decl;
for (ed.variant_names) |v| {
if (std.mem.eql(u8, v, member_name)) {
return self.sendSpanLocation(id_json, lookup.doc, lookup.node.span, origin_doc, origin);
}
}
} else if (lookup.node.data == .union_decl) {
const ud = lookup.node.data.union_decl;
for (ud.field_names) |fname| {
if (std.mem.eql(u8, fname, member_name)) {
return self.sendSpanLocation(id_json, lookup.doc, lookup.node.span, origin_doc, origin);
}
}
}
return false;
}
/// Resolve qualified name as struct/union method or field, send definition location.
fn resolveStructMemberDef(self: *Server, id_json: []const u8, sema: SemaResult, doc: *const Document, ns: []const u8, member: []const u8, origin: sx.ast.Span) !bool {
// Try ns as a type name directly
if (self.findTypeDeclNode(sema, doc, ns)) |lookup| {
if (try self.sendMemberLocation(id_json, lookup, member, doc, origin)) return true;
}
// Try ns as a variable name → resolve to struct type
if (resolveStructTypeName(sema, doc, ns)) |type_name| {
if (self.findTypeDeclNode(sema, doc, type_name)) |lookup| {
if (try self.sendMemberLocation(id_json, lookup, member, doc, origin)) return true;
}
}
return false;
}
/// Send a go-to-definition response pointing to a span in a document.
fn sendSpanLocation(self: *Server, id_json: []const u8, target_doc: *const Document, target_span: sx.ast.Span, origin_doc: *const Document, origin_span: sx.ast.Span) !bool {
const target_range = spanToRange(target_doc.source, target_span);
const target_uri = try std.fmt.allocPrint(self.allocator, "file://{s}", .{target_doc.path});
const src_range = spanToRange(origin_doc.source, origin_span);
const loc_json = try lsp.locationLinkJson(self.allocator, target_uri, target_range, src_range);
try self.sendResponse(id_json, loc_json);
return true;
}
/// Find an import by namespace name (falls back to last good imports).
fn findImportByNs(_: *Server, doc: *const Document, ns_name: []const u8) ?doc_mod.Import {
const imports_lists = [_][]const doc_mod.Import{ doc.imports, doc.last_good_imports };
@@ -1958,48 +2043,40 @@ pub const Server = struct {
const sema = doc.sema orelse return null;
const struct_name = resolveStructTypeName(sema, doc, obj_name) orelse return null;
for (sema.symbols) |sym| {
if (sym.kind != .struct_type or !std.mem.eql(u8, sym.name, struct_name)) continue;
const lookup = self.findTypeDeclNode(sema, doc, struct_name) orelse return null;
if (lookup.node.data != .struct_decl) return null;
const sd = lookup.node.data.struct_decl;
const lookup_doc = lookup.doc;
const lookup_doc = self.resolveSymbolDoc(doc, sym);
const lookup_root = lookup_doc.root orelse return null;
for (sd.field_names, 0..) |fn_, fi| {
if (!std.mem.eql(u8, fn_, field_name)) continue;
if (sx.sema.findNodeAtOffset(lookup_root, sym.def_span.start)) |node| {
if (node.data == .struct_decl) {
const sd = node.data.struct_decl;
for (sd.field_names, 0..) |fn_, fi| {
if (!std.mem.eql(u8, fn_, field_name)) continue;
var buf = std.ArrayList(u8).empty;
var buf = std.ArrayList(u8).empty;
// Doc comment above field
const fn_addr = @intFromPtr(fn_.ptr);
const src_addr = @intFromPtr(lookup_doc.source.ptr);
const src_end = src_addr + lookup_doc.source.len;
if (fn_addr >= src_addr and fn_addr < src_end) {
const field_offset = @as(u32, @intCast(fn_addr - src_addr));
if (extractDocComment(lookup_doc.source, field_offset)) |comment| {
try buf.appendSlice(self.allocator, comment);
try buf.appendSlice(self.allocator, "\n\n");
}
}
try buf.appendSlice(self.allocator, "```sx\n");
try buf.appendSlice(self.allocator, struct_name);
try buf.append(self.allocator, '.');
try buf.appendSlice(self.allocator, field_name);
if (fi < sd.field_types.len) {
if (sd.field_types[fi].data == .type_expr) {
try buf.appendSlice(self.allocator, " : ");
try buf.appendSlice(self.allocator, sd.field_types[fi].data.type_expr.name);
}
}
try buf.appendSlice(self.allocator, "\n```");
return buf.items;
}
// Doc comment above field
const fn_addr = @intFromPtr(fn_.ptr);
const src_addr = @intFromPtr(lookup_doc.source.ptr);
const src_end = src_addr + lookup_doc.source.len;
if (fn_addr >= src_addr and fn_addr < src_end) {
const field_offset = @as(u32, @intCast(fn_addr - src_addr));
if (extractDocComment(lookup_doc.source, field_offset)) |comment| {
try buf.appendSlice(self.allocator, comment);
try buf.appendSlice(self.allocator, "\n\n");
}
}
break;
try buf.appendSlice(self.allocator, "```sx\n");
try buf.appendSlice(self.allocator, struct_name);
try buf.append(self.allocator, '.');
try buf.appendSlice(self.allocator, field_name);
if (fi < sd.field_types.len) {
if (sd.field_types[fi].data == .type_expr) {
try buf.appendSlice(self.allocator, " : ");
try buf.appendSlice(self.allocator, sd.field_types[fi].data.type_expr.name);
}
}
try buf.appendSlice(self.allocator, "\n```");
return buf.items;
}
return null;
}
@@ -2007,39 +2084,37 @@ pub const Server = struct {
fn formatEnumVariantHover(self: *Server, doc: *const Document, variant_name: []const u8) !?[]const u8 {
const sema = doc.sema orelse return null;
// Search all enum types for the variant
for (sema.symbols) |sym| {
if (sym.kind != .enum_type) continue;
const lookup_doc = self.resolveSymbolDoc(doc, sym);
const lookup_root = lookup_doc.root orelse continue;
const lookup = self.findTypeDeclNode(sema, doc, sym.name) orelse continue;
if (lookup.node.data != .enum_decl) continue;
const ed = lookup.node.data.enum_decl;
const lookup_doc = lookup.doc;
if (sx.sema.findNodeAtOffset(lookup_root, sym.def_span.start)) |node| {
if (node.data == .enum_decl) {
const ed = node.data.enum_decl;
for (ed.variant_names) |v| {
if (!std.mem.eql(u8, v, variant_name)) continue;
for (ed.variant_names) |v| {
if (!std.mem.eql(u8, v, variant_name)) continue;
var buf = std.ArrayList(u8).empty;
var buf = std.ArrayList(u8).empty;
const v_addr = @intFromPtr(v.ptr);
const src_addr2 = @intFromPtr(lookup_doc.source.ptr);
const src_end2 = src_addr2 + lookup_doc.source.len;
if (v_addr >= src_addr2 and v_addr < src_end2) {
const variant_offset = @as(u32, @intCast(v_addr - src_addr2));
if (extractDocComment(lookup_doc.source, variant_offset)) |comment| {
try buf.appendSlice(self.allocator, comment);
try buf.appendSlice(self.allocator, "\n\n");
}
}
try buf.appendSlice(self.allocator, "```sx\n");
try buf.appendSlice(self.allocator, sym.name);
try buf.append(self.allocator, '.');
try buf.appendSlice(self.allocator, variant_name);
try buf.appendSlice(self.allocator, "\n```");
return buf.items;
const v_addr = @intFromPtr(v.ptr);
const src_addr2 = @intFromPtr(lookup_doc.source.ptr);
const src_end2 = src_addr2 + lookup_doc.source.len;
if (v_addr >= src_addr2 and v_addr < src_end2) {
const variant_offset = @as(u32, @intCast(v_addr - src_addr2));
if (extractDocComment(lookup_doc.source, variant_offset)) |comment| {
try buf.appendSlice(self.allocator, comment);
try buf.appendSlice(self.allocator, "\n\n");
}
}
try buf.appendSlice(self.allocator, "```sx\n");
try buf.appendSlice(self.allocator, sym.name);
try buf.append(self.allocator, '.');
try buf.appendSlice(self.allocator, variant_name);
try buf.appendSlice(self.allocator, "\n```");
return buf.items;
}
}
return null;