Generics overhaul & improvements

src/DocumentScope.zig

@@ -353,6 +353,7 @@ pub const Scope = struct {
     };
 
     pub const OptionalIndex = enum(u32) {
+        root,
         none = std.math.maxInt(u32),
         _,
 

src/ast.zig

@@ -1572,11 +1572,46 @@ pub fn nodesOverlappingIndex(allocator: std.mem.Allocator, tree: Ast, index: usi
     };
 
     var context: Context = .{ .index = index, .allocator = allocator };
+    defer context.nodes.deinit(allocator);
     try iterateChildren(tree, .root, &context, error{OutOfMemory}, Context.append);
     try context.nodes.append(allocator, .root);
     return try context.nodes.toOwnedSlice(allocator);
 }
 
+/// returns a list of nodes that overlap with the given source code index.
+/// the list may include nodes that were discarded during error recovery in the Zig parser.
+/// sorted from smallest to largest.
+/// caller owns the returned memory.
+/// this function can be removed when the parser has been improved.
+pub fn nodesOverlappingIndexIncludingParseErrors(allocator: std.mem.Allocator, tree: Ast, source_index: usize) error{OutOfMemory}![]Ast.Node.Index {
+    const NodeLoc = struct {
+        node: Ast.Node.Index,
+        loc: offsets.Loc,
+
+        fn lessThan(_: void, lhs: @This(), rhs: @This()) bool {
+            return rhs.loc.start < lhs.loc.start and lhs.loc.end < rhs.loc.end;
+        }
+    };
+
+    var node_locs: std.ArrayListUnmanaged(NodeLoc) = .empty;
+    defer node_locs.deinit(allocator);
+    for (0..tree.nodes.len) |i| {
+        const node: Ast.Node.Index = @enumFromInt(i);
+        const loc = offsets.nodeToLoc(tree, node);
+        if (loc.start <= source_index and source_index <= loc.end) {
+            try node_locs.append(allocator, .{ .node = node, .loc = loc });
+        }
+    }
+
+    std.mem.sort(NodeLoc, node_locs.items, {}, NodeLoc.lessThan);
+
+    const nodes = try allocator.alloc(Ast.Node.Index, node_locs.items.len);
+    for (node_locs.items, nodes) |node_loc, *node| {
+        node.* = node_loc.node;
+    }
+    return nodes;
+}
+
 /// returns a list of nodes that together encloses the given source code range
 /// caller owns the returned memory
 pub fn nodesAtLoc(allocator: std.mem.Allocator, tree: Ast, loc: offsets.Loc) error{OutOfMemory}![]Ast.Node.Index {

src/features/hover.zig

@@ -41,7 +41,10 @@ fn hoverSymbolRecursive(
 
     const def_str = switch (decl_handle.decl) {
         .ast_node => |node| def: {
-            if (try analyser.resolveVarDeclAlias(.of(node, handle))) |result| {
+            if (try analyser.resolveVarDeclAlias(.{
+                .node_handle = .of(node, handle),
+                .container_type = decl_handle.container_type,
+            })) |result| {
                 return try hoverSymbolRecursive(analyser, arena, result, markup_kind, doc_strings);
             }
 

src/features/semantic_tokens.zig

@@ -277,7 +277,7 @@ fn colorIdentifierBasedOnType(
             new_tok_mod.generic = true;
         }
 
-        const has_self_param = Analyser.hasSelfParam(type_node);
+        const has_self_param = builder.analyser.hasSelfParam(type_node);
 
         try writeTokenMod(builder, target_tok, if (has_self_param) .method else .function, new_tok_mod);
     } else {
@@ -419,8 +419,13 @@ fn writeNodeTokens(builder: *Builder, node: Ast.Node.Index) error{OutOfMemory}!v
                 is_generic = func_ty.isGenericFunc();
                 if (func_ty.isTypeFunc()) {
                     func_name_tok_type = .type;
-                } else if (Analyser.hasSelfParam(func_ty)) {
-                    func_name_tok_type = .method;
+                } else {
+                    const container_ty = try builder.analyser.innermostContainer(handle, tree.tokenStart(fn_proto.ast.fn_token));
+                    if (container_ty.data.container.scope_handle.scope != .root and
+                        Analyser.firstParamIs(func_ty, container_ty))
+                    {
+                        func_name_tok_type = .method;
+                    }
                 }
             }
 
@@ -620,7 +625,8 @@ fn writeNodeTokens(builder: *Builder, node: Ast.Node.Index) error{OutOfMemory}!v
 
                 if (try builder.analyser.resolveTypeOfNode(.of(type_expr, handle))) |struct_type| {
                     switch (struct_type.data) {
-                        .container => |scope_handle| {
+                        .container => |info| {
+                            const scope_handle = info.scope_handle;
                             field_token_type = fieldTokenType(scope_handle.toNode(), scope_handle.handle, false);
                         },
                         else => {},
@@ -1131,7 +1137,7 @@ fn writeFieldAccess(builder: *Builder, node: Ast.Node.Index) error{OutOfMemory}!
 
     try writeNodeTokens(builder, lhs_node);
 
-    const lhs = try builder.analyser.resolveTypeOfNode(.{ .node = lhs_node, .handle = handle }) orelse {
+    const lhs = try builder.analyser.resolveTypeOfNode(.of(lhs_node, handle)) orelse {
         try writeToken(builder, field_name_token, .variable);
         return;
     };
@@ -1148,7 +1154,7 @@ fn writeFieldAccess(builder: *Builder, node: Ast.Node.Index) error{OutOfMemory}!
             const decl_node = decl_type.decl.ast_node;
             if (!decl_type.handle.tree.nodeTag(decl_node).isContainerField()) break :field_blk;
             if (lhs_type.data != .container) break :field_blk;
-            const scope_handle = lhs_type.data.container;
+            const scope_handle = lhs_type.data.container.scope_handle;
             const tt = fieldTokenType(
                 scope_handle.toNode(),
                 scope_handle.handle,

src/features/signature_help.zig

@@ -36,7 +36,7 @@ fn fnProtoToSignatureInfo(
     })});
 
     const arg_idx = if (skip_self_param) blk: {
-        const has_self_param = Analyser.hasSelfParam(func_type);
+        const has_self_param = analyser.hasSelfParam(func_type);
         break :blk commas + @intFromBool(has_self_param);
     } else commas;
 

tests/analysis/generics.zig

@@ -0,0 +1,228 @@
+fn Foo(T: type) type {
+    return struct {
+        fn bar(U: type, t: ?T, u: ?U) void {
+            _ = .{ t, u };
+        }
+
+        fn baz(U: type, t: T, u: U) T {
+            return t + u;
+        }
+
+        fn qux(U: type, t: T, u: U) @TypeOf(t, u) {
+            return t + u;
+        }
+    };
+}
+
+const foo = Foo(u8){};
+//    ^^^ (Foo(u8))()
+
+// TODO this should be `fn (U: type, ?u8, ?U) void`
+const bar_fn = Foo(u8).bar;
+//    ^^^^^^ (fn (type, ?u8, ?U) void)()
+
+const bar_call = Foo(u8).bar(i32, null, null);
+//    ^^^^^^^^ (void)()
+
+// TODO this should be `fn (U: type, i32, U) i32`
+const baz_fn = Foo(i32).baz;
+//    ^^^^^^ (fn (type, i32, U) i32)()
+
+const baz_call = Foo(i32).baz(u8, -42, 42);
+//    ^^^^^^^^ (i32)()
+
+// TODO this should be `fn (U: type, u8, U) anytype`
+const qux_fn = Foo(u8).qux;
+//    ^^^^^^ (fn (type, u8, U) u8)()
+
+// TODO this should be `i32`
+const qux_call = Foo(u8).qux(i32, 42, -42);
+//    ^^^^^^^^ (u8)()
+
+fn fizz(T: type) ?fn () error{}!struct { ??T } {
+    return null;
+}
+
+// TODO this should be `fn (T: type) ?fn () error{}!struct { ??T })()`
+const fizz_fn = fizz;
+//    ^^^^^^^ (fn (type) ?fn () error{}!struct { ??T })()
+
+const fizz_call = fizz(u8);
+//    ^^^^^^^^^ (?fn () error{}!struct { ??u8 })()
+
+comptime {
+    // Use @compileLog to verify the expected type with the compiler:
+    // @compileLog(foo);
+}
+
+fn Point1(comptime T: type) type {
+    return struct {
+        x: T,
+        y: T,
+        fn normSquared(self: Point1(T)) T {
+            _ = self;
+            //  ^^^^ (Point1(T))()
+        }
+    };
+}
+
+fn parameter(comptime T: type, in: T) void {
+    _ = in;
+    //  ^^ (T)()
+}
+
+fn taggedUnion(comptime T: type, in: union(enum) { a: T, b: T }) void {
+    switch (in) {
+        .a => |a| {
+            _ = a;
+            //  ^ (T)()
+        },
+        .b => |b| {
+            _ = b;
+            //  ^ (T)()
+        },
+    }
+}
+
+fn Option(comptime T: type) type {
+    return struct {
+        item: ?T,
+        const none: @This() = undefined;
+        const alias = none;
+        const default = init();
+        fn init() @This() {}
+    };
+}
+
+const option_none: Option(u8) = .none;
+//                              ^^^^^ (Option(u8))()
+
+const option_alias: Option(u8) = .alias;
+//                               ^^^^^^ (Option(u8))()
+
+const option_default: Option(u8) = .default;
+//                                 ^^^^^^^^ (Option(u8))()
+
+const option_init: Option(u8) = .init();
+//                              ^^^^^ (fn () Option(u8))()
+
+fn GenericUnion(T: type) type {
+    return union {
+        field: T,
+        const decl: T = undefined;
+    };
+}
+
+const generic_union_decl = GenericUnion(u8).decl;
+//    ^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_union: GenericUnion(u8) = .{ .field = 1 };
+//    ^^^^^^^^^^^^^ (GenericUnion(u8))()
+
+const generic_union_field = generic_union.field;
+//    ^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_union_tag = GenericUnion(u8).field;
+//    ^^^^^^^^^^^^^^^^^ (unknown)()
+
+fn GenericTaggedUnion(T: type) type {
+    return union(enum) {
+        field: T,
+        const decl: T = undefined;
+    };
+}
+
+const generic_tagged_union_decl = GenericTaggedUnion(u8).decl;
+//    ^^^^^^^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_tagged_union: GenericTaggedUnion(u8) = .{ .field = 1 };
+//    ^^^^^^^^^^^^^^^^^^^^ (GenericTaggedUnion(u8))()
+
+const generic_tagged_union_field = generic_tagged_union.field;
+//    ^^^^^^^^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_tagged_union_tag = GenericTaggedUnion(u8).field;
+//    ^^^^^^^^^^^^^^^^^^^^^^^^ (@typeInfo(GenericTaggedUnion(u8)).@"union".tag_type.?)()
+
+fn GenericEnum(T: type) type {
+    return enum {
+        field,
+        const decl: T = undefined;
+    };
+}
+
+const generic_enum_decl = GenericEnum(u8).decl;
+//    ^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_enum: GenericEnum(u8) = .field;
+//    ^^^^^^^^^^^^ (GenericEnum(u8))()
+
+const generic_enum_field = generic_enum.field;
+//    ^^^^^^^^^^^^^^^^^^ (unknown)()
+
+const generic_enum_tag = GenericEnum(u8).field;
+//    ^^^^^^^^^^^^^^^^ (GenericEnum(u8))()
+
+fn GenericStruct(T: type) type {
+    return struct {
+        field: T,
+        const decl: T = undefined;
+    };
+}
+
+const generic_struct_decl = GenericStruct(u8).decl;
+//    ^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_struct: GenericStruct(u8) = .{ .field = 1 };
+//    ^^^^^^^^^^^^^^ (GenericStruct(u8))()
+
+const generic_struct_field = generic_struct.field;
+//    ^^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_struct_tag = GenericStruct(u8).field;
+//    ^^^^^^^^^^^^^^^^^^ (unknown)()
+
+fn Map(Context: type) type {
+    return struct {
+        unmanaged: MapUnmanaged(Context),
+        ctx: Context,
+        const Self = @This();
+        fn clone(self: Self) Self {
+            const unmanaged = self.unmanaged.cloneContext(self.ctx);
+            //    ^^^^^^^^^ (MapUnmanaged(either type))()
+            return .{ .unmanaged = unmanaged, .ctx = self.ctx };
+        }
+        fn clone2(self: Self) Self {
+            const unmanaged = self.unmanaged.cloneContext2(self.ctx);
+            //    ^^^^^^^^^ (MapUnmanaged(*either type))()
+            return .{ .unmanaged = unmanaged, .ctx = self.ctx };
+        }
+    };
+}
+
+fn MapUnmanaged(Context: type) type {
+    return struct {
+        size: u32,
+        const Self = @This();
+        fn clone(self: Self) Self {
+            return self.cloneContext(@as(Context, undefined));
+        }
+        fn cloneContext(self: Self, new_ctx: anytype) MapUnmanaged(@TypeOf(new_ctx)) {
+            _ = self;
+        }
+        fn clone2(self: Self) Self {
+            return self.cloneContext2(@as(Context, undefined));
+        }
+        fn cloneContext2(self: Self, new_ctx: anytype) MapUnmanaged(*@TypeOf(new_ctx)) {
+            _ = self;
+        }
+    };
+}
+
+const some_list: std.ArrayListUnmanaged(u8) = .empty;
+//    ^^^^^^^^^ (ArrayListAlignedUnmanaged(u8))()
+
+const some_list_items = some_list.items;
+//    ^^^^^^^^^^^^^^^ ([]u8)()
+
+const std = @import("std");