Fix resolved type of @This() in a generic function

When looking for the innermost container, only add type parameters
that are defined outside of the container. For example:

    fn Foo(A: type) type {
        return struct {
            fn bar(B: type) @this() {
                ...
            }
        }
    }

Only `A` should be added to the set of type parameters for `Foo(A)`.

Author: FnControlOption

src/analysis.zig

@@ -5695,12 +5695,21 @@ pub fn innermostContainer(analyser: *Analyser, handle: *DocumentStore.Handle, so
         .is_type_val = true,
     };
 
+    var pending_meta_params: TokenToTypeMap = .empty;
+    defer pending_meta_params.deinit(analyser.gpa);
+
     var current: DocumentScope.Scope.Index = .root;
     var meta_params: TokenToTypeMap = .empty;
     var scope_iterator = iterateEnclosingScopes(&document_scope, source_index);
     while (scope_iterator.next().unwrap()) |scope_index| {
         switch (document_scope.getScopeTag(scope_index)) {
-            .container => current = scope_index,
+            .container => {
+                current = scope_index;
+                for (pending_meta_params.keys(), pending_meta_params.values()) |token_handle, ty| {
+                    try meta_params.put(analyser.arena, token_handle, ty);
+                }
+                pending_meta_params.clearRetainingCapacity();
+            },
             .function => {
                 const function_node = document_scope.getScopeAstNode(scope_index).?;
                 var buf: [1]Ast.Node.Index = undefined;
@@ -5712,7 +5721,7 @@ pub fn innermostContainer(analyser: *Analyser, handle: *DocumentStore.Handle, so
                     const param_name_token = param.name_token orelse continue;
                     const token_handle: TokenWithHandle = .{ .token = param_name_token, .handle = handle };
                     const ty: Type = .{ .data = .{ .type_parameter = token_handle }, .is_type_val = true };
-                    try meta_params.put(analyser.arena, token_handle, ty);
+                    try pending_meta_params.put(analyser.gpa, token_handle, ty);
                 }
             },
             else => {},

tests/lsp_features/completion.zig

@@ -4322,6 +4322,22 @@ test "insert replace behaviour - file system completions" {
     // zig fmt: on
 }
 
+test "generic function with @This() as self param" {
+    try testCompletion(
+        \\const Foo = struct {
+        \\    fn bar(_: *const @This(), comptime _: type) void {}
+        \\};
+        \\const foo: Foo = .{};
+        \\const _ = foo.<cursor>
+    , &.{
+        .{
+            .label = "bar",
+            .kind = .Function,
+            .detail = "fn (_: *const Foo, comptime _: type) void",
+        },
+    });
+}
+
 fn testCompletion(source: []const u8, expected_completions: []const Completion) !void {
     try testCompletionWithOptions(source, expected_completions, .{});
 }

tests/lsp_features/semantic_tokens.zig

@@ -2086,6 +2086,45 @@ test "weird code" {
     , &.{}, .{ .mode = .zon });
 }
 
+test "generic function with @This() as self param" {
+    try testSemanticTokens(
+        \\const Demo = struct {
+        \\    fn bar(_: *@This(), comptime _: type) void {}
+        \\};
+        \\test {
+        \\    var demo: Demo = .{};
+        \\    Demo.bar(&demo, usize);
+        \\    demo.bar(usize);
+        \\}
+    , &.{
+        .{ "const", .keyword, .{} },
+        .{ "Demo", .namespace, .{ .declaration = true } },
+        .{ "=", .operator, .{} },
+        .{ "struct", .keyword, .{} },
+        .{ "fn", .keyword, .{} },
+        .{ "bar", .method, .{ .declaration = true, .generic = true } },
+        .{ "_", .parameter, .{ .declaration = true } },
+        .{ "@This", .builtin, .{} },
+        .{ "comptime", .keyword, .{} },
+        .{ "_", .typeParameter, .{ .declaration = true } },
+        .{ "type", .type, .{} },
+        .{ "void", .type, .{} },
+        .{ "test", .keyword, .{} },
+        .{ "var", .keyword, .{} },
+        .{ "demo", .variable, .{ .declaration = true, .mutable = true } },
+        .{ "Demo", .namespace, .{} },
+        .{ "=", .operator, .{} },
+        .{ "Demo", .namespace, .{} },
+        .{ "bar", .function, .{ .generic = true } },
+        .{ "&", .operator, .{} },
+        .{ "demo", .variable, .{ .mutable = true } },
+        .{ "usize", .type, .{} },
+        .{ "demo", .variable, .{ .mutable = true } },
+        .{ "bar", .function, .{ .generic = true } },
+        .{ "usize", .type, .{} },
+    });
+}
+
 const TokenData = struct {
     []const u8,
     zls.semantic_tokens.TokenType,