Fix Go to Type Definition (#1352)

Author: FnControlOption

src/Server.zig

@@ -883,13 +883,13 @@ fn gotoDefinitionHandler(
     arena: std.mem.Allocator,
     request: types.DefinitionParams,
 ) Error!ResultType("textDocument/definition") {
-    return server.gotoHandler(arena, true, request);
+    return server.gotoHandler(arena, .definition, request);
 }
 
 fn gotoHandler(
     server: *Server,
     arena: std.mem.Allocator,
-    comptime resolve_alias: bool,
+    comptime kind: goto.GotoKind,
     request: types.DefinitionParams,
 ) Error!ResultType("textDocument/definition") {
     if (request.position.character == 0) return null;
@@ -901,12 +901,12 @@ fn gotoHandler(
     defer analyser.deinit();
 
     return .{
-        .array_of_DefinitionLink = try goto.goto(&analyser, &server.document_store, arena, handle, source_index, resolve_alias, server.offset_encoding) orelse return null,
+        .array_of_DefinitionLink = try goto.goto(&analyser, &server.document_store, arena, handle, source_index, kind, server.offset_encoding) orelse return null,
     };
 }
 
-fn gotoTypeDeclarationHandler(server: *Server, arena: std.mem.Allocator, request: types.TypeDefinitionParams) Error!ResultType("textDocument/typeDefinition") {
-    const response = (try server.gotoHandler(arena, false, .{
+fn gotoTypeDefinitionHandler(server: *Server, arena: std.mem.Allocator, request: types.TypeDefinitionParams) Error!ResultType("textDocument/typeDefinition") {
+    const response = (try server.gotoHandler(arena, .type_definition, .{
         .textDocument = request.textDocument,
         .position = request.position,
         .workDoneToken = request.workDoneToken,
@@ -916,7 +916,7 @@ fn gotoTypeDeclarationHandler(server: *Server, arena: std.mem.Allocator, request
 }
 
 fn gotoImplementationHandler(server: *Server, arena: std.mem.Allocator, request: types.ImplementationParams) Error!ResultType("textDocument/implementation") {
-    const response = (try server.gotoHandler(arena, true, .{
+    const response = (try server.gotoHandler(arena, .definition, .{
         .textDocument = request.textDocument,
         .position = request.position,
         .workDoneToken = request.workDoneToken,
@@ -926,7 +926,7 @@ fn gotoImplementationHandler(server: *Server, arena: std.mem.Allocator, request:
 }
 
 fn gotoDeclarationHandler(server: *Server, arena: std.mem.Allocator, request: types.DeclarationParams) Error!ResultType("textDocument/declaration") {
-    const response = (try server.gotoHandler(arena, false, .{
+    const response = (try server.gotoHandler(arena, .declaration, .{
         .textDocument = request.textDocument,
         .position = request.position,
         .workDoneToken = request.workDoneToken,
@@ -1614,7 +1614,7 @@ pub fn sendRequestSync(server: *Server, arena: std.mem.Allocator, comptime metho
         .@"textDocument/completion" => try server.completionHandler(arena, params),
         .@"textDocument/signatureHelp" => try server.signatureHelpHandler(arena, params),
         .@"textDocument/definition" => try server.gotoDefinitionHandler(arena, params),
-        .@"textDocument/typeDefinition" => try server.gotoTypeDeclarationHandler(arena, params),
+        .@"textDocument/typeDefinition" => try server.gotoTypeDefinitionHandler(arena, params),
         .@"textDocument/implementation" => try server.gotoImplementationHandler(arena, params),
         .@"textDocument/declaration" => try server.gotoDeclarationHandler(arena, params),
         .@"textDocument/hover" => try server.hoverHandler(arena, params),

src/analysis.zig

@@ -1842,14 +1842,14 @@ pub const TypeWithHandle = struct {
         };
     }
 
-    pub fn definitionToken(self: TypeWithHandle) ?Ast.TokenIndex {
-        if (self.type.is_type_val) {
-            switch (self.type.data) {
-                .other => |n| return self.handle.tree.firstToken(n),
-                else => {},
-            }
-        }
-        return null;
+    pub fn typeDefinitionToken(self: TypeWithHandle) ?TokenWithHandle {
+        return switch (self.type.data) {
+            .other => |n| .{
+                .token = self.handle.tree.firstToken(n),
+                .handle = self.handle,
+            },
+            else => null,
+        };
     }
 
     pub fn docComments(self: TypeWithHandle, allocator: std.mem.Allocator) !?[]const u8 {
@@ -2574,8 +2574,10 @@ pub const DeclWithHandle = struct {
                 else => {},
             }
             if (try self.resolveType(analyser)) |resolved_type| {
-                if (resolved_type.definitionToken()) |token| {
-                    return .{ .token = token, .handle = resolved_type.handle };
+                if (resolved_type.type.is_type_val) {
+                    if (resolved_type.typeDefinitionToken()) |token| {
+                        return token;
+                    }
                 }
             }
         }

src/features/goto.zig

@@ -11,17 +11,33 @@ const tracy = @import("../tracy.zig");
 const Analyser = @import("../analysis.zig");
 const DocumentStore = @import("../DocumentStore.zig");
 
+pub const GotoKind = enum {
+    declaration,
+    definition,
+    type_definition,
+};
+
 pub fn gotoDefinitionSymbol(
     analyser: *Analyser,
     name_range: types.Range,
     decl_handle: Analyser.DeclWithHandle,
-    resolve_alias: bool,
+    kind: GotoKind,
     offset_encoding: offsets.Encoding,
 ) error{OutOfMemory}!?types.DefinitionLink {
     const tracy_zone = tracy.trace(@src());
     defer tracy_zone.end();
 
-    const token_handle = try decl_handle.definitionToken(analyser, resolve_alias);
+    const token_handle = switch (kind) {
+        .declaration => try decl_handle.definitionToken(analyser, false),
+        .definition => try decl_handle.definitionToken(analyser, true),
+        .type_definition => blk: {
+            const resolved_type = try decl_handle.resolveType(analyser) orelse
+                return null;
+
+            break :blk resolved_type.typeDefinitionToken() orelse
+                return null;
+        },
+    };
     const target_range = offsets.tokenToRange(token_handle.handle.tree, token_handle.token, offset_encoding);
 
     return types.DefinitionLink{
@@ -37,6 +53,7 @@ pub fn gotoDefinitionLabel(
     arena: std.mem.Allocator,
     handle: *const DocumentStore.Handle,
     pos_index: usize,
+    kind: GotoKind,
     offset_encoding: offsets.Encoding,
 ) error{OutOfMemory}!?types.DefinitionLink {
     const tracy_zone = tracy.trace(@src());
@@ -46,15 +63,15 @@ pub fn gotoDefinitionLabel(
     const name_loc = Analyser.identifierLocFromPosition(pos_index, handle) orelse return null;
     const name = offsets.locToSlice(handle.text, name_loc);
     const decl = (try Analyser.getLabelGlobal(pos_index, handle, name)) orelse return null;
-    return try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), decl, false, offset_encoding);
+    return try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), decl, kind, offset_encoding);
 }
 
 pub fn gotoDefinitionGlobal(
     analyser: *Analyser,
     arena: std.mem.Allocator,
     handle: *const DocumentStore.Handle,
     pos_index: usize,
-    resolve_alias: bool,
+    kind: GotoKind,
     offset_encoding: offsets.Encoding,
 ) error{OutOfMemory}!?types.DefinitionLink {
     const tracy_zone = tracy.trace(@src());
@@ -64,14 +81,15 @@ pub fn gotoDefinitionGlobal(
     const name_loc = Analyser.identifierLocFromPosition(pos_index, handle) orelse return null;
     const name = offsets.locToSlice(handle.text, name_loc);
     const decl = (try analyser.getSymbolGlobal(pos_index, handle, name)) orelse return null;
-    return try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), decl, resolve_alias, offset_encoding);
+    return try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), decl, kind, offset_encoding);
 }
 
 pub fn gotoDefinitionEnumLiteral(
     analyser: *Analyser,
     arena: std.mem.Allocator,
     handle: *const DocumentStore.Handle,
     source_index: usize,
+    kind: GotoKind,
     offset_encoding: offsets.Encoding,
 ) error{OutOfMemory}!?types.DefinitionLink {
     const tracy_zone = tracy.trace(@src());
@@ -80,7 +98,7 @@ pub fn gotoDefinitionEnumLiteral(
     const name_loc = Analyser.identifierLocFromPosition(source_index, handle) orelse return null;
     const name = offsets.locToSlice(handle.text, name_loc);
     const decl = (try analyser.getSymbolEnumLiteral(arena, handle, source_index, name)) orelse return null;
-    return try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), decl, false, offset_encoding);
+    return try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), decl, kind, offset_encoding);
 }
 
 pub fn gotoDefinitionBuiltin(
@@ -126,7 +144,7 @@ pub fn gotoDefinitionFieldAccess(
     handle: *const DocumentStore.Handle,
     source_index: usize,
     loc: offsets.Loc,
-    resolve_alias: bool,
+    kind: GotoKind,
     offset_encoding: offsets.Encoding,
 ) error{OutOfMemory}!?[]const types.DefinitionLink {
     const tracy_zone = tracy.trace(@src());
@@ -139,7 +157,7 @@ pub fn gotoDefinitionFieldAccess(
     var locs = std.ArrayListUnmanaged(types.DefinitionLink){};
 
     for (accesses) |access| {
-        if (try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), access, resolve_alias, offset_encoding)) |l|
+        if (try gotoDefinitionSymbol(analyser, offsets.locToRange(handle.text, name_loc, offset_encoding), access, kind, offset_encoding)) |l|
             try locs.append(arena, l);
     }
 
@@ -208,22 +226,22 @@ pub fn goto(
     arena: std.mem.Allocator,
     handle: *const DocumentStore.Handle,
     source_index: usize,
-    resolve_alias: bool,
+    kind: GotoKind,
     offset_encoding: offsets.Encoding,
 ) !?[]const types.DefinitionLink {
     const pos_context = try Analyser.getPositionContext(arena, handle.text, source_index, true);
     var links = std.ArrayListUnmanaged(types.DefinitionLink){};
 
     try links.append(arena, switch (pos_context) {
         .builtin => |loc| try gotoDefinitionBuiltin(document_store, handle, loc, offset_encoding),
-        .var_access => try gotoDefinitionGlobal(analyser, arena, handle, source_index, resolve_alias, offset_encoding),
-        .field_access => |loc| return try gotoDefinitionFieldAccess(analyser, arena, handle, source_index, loc, resolve_alias, offset_encoding),
+        .var_access => try gotoDefinitionGlobal(analyser, arena, handle, source_index, kind, offset_encoding),
+        .field_access => |loc| return try gotoDefinitionFieldAccess(analyser, arena, handle, source_index, loc, kind, offset_encoding),
         .import_string_literal,
         .cinclude_string_literal,
         .embedfile_string_literal,
         => try gotoDefinitionString(document_store, arena, pos_context, handle, offset_encoding),
-        .label => try gotoDefinitionLabel(analyser, arena, handle, source_index, offset_encoding),
-        .enum_literal => try gotoDefinitionEnumLiteral(analyser, arena, handle, source_index, offset_encoding),
+        .label => try gotoDefinitionLabel(analyser, arena, handle, source_index, kind, offset_encoding),
+        .enum_literal => try gotoDefinitionEnumLiteral(analyser, arena, handle, source_index, kind, offset_encoding),
         else => null,
     } orelse return null);