don't replace non symbol characters in code completions

Co-Authored-By: xdBronch <[email protected]>

Author: Techatrix

src/ast.zig

@@ -400,6 +400,24 @@ fn findMatchingRBrace(tree: *const Ast, start: Ast.TokenIndex) ?Ast.TokenIndex {
     return if (std.mem.findScalarPos(std.zig.Token.Tag, tree.tokens.items(.tag), start, .r_brace)) |index| @intCast(index) else null;
 }
 
+pub fn isKeyword(tag: std.zig.Token.Tag) bool {
+    const tags = std.zig.Token.keywords.values();
+    var first_keyword: std.meta.Tag(std.zig.Token.Tag) = @intFromEnum(tags[0]);
+    var last_keyword: std.meta.Tag(std.zig.Token.Tag) = @intFromEnum(tags[tags.len - 1]);
+    for (std.zig.Token.keywords.values()) |token_tag| {
+        first_keyword = @min(@intFromEnum(token_tag), first_keyword);
+        last_keyword = @max(@intFromEnum(token_tag), last_keyword);
+    }
+    return first_keyword <= @intFromEnum(tag) and @intFromEnum(tag) <= last_keyword;
+}
+
+test isKeyword {
+    try std.testing.expect(!isKeyword(.invalid));
+    try std.testing.expect(!isKeyword(.container_doc_comment));
+    try std.testing.expect(isKeyword(.keyword_addrspace));
+    try std.testing.expect(isKeyword(.keyword_while));
+}
+
 /// Similar to `std.zig.Ast.lastToken` but also handles ASTs with syntax errors.
 pub fn lastToken(tree: *const Ast, node: Node.Index) Ast.TokenIndex {
     var n = node;

src/features/completions.zig

@@ -487,7 +487,10 @@ fn prepareCompletionLoc(tree: *const Ast, source_index: usize) offsets.Loc {
     const token = switch (offsets.sourceIndexToTokenIndex(tree, source_index)) {
         .none => return fallback_loc,
         .one => |token| token,
-        .between => |data| data.left,
+        .between => |data| switch (tree.tokenTag(data.left)) {
+            .identifier, .builtin, .invalid => data.left,
+            else => |tag| if (ast.isKeyword(tag)) data.left else data.right,
+        },
     };
     switch (tree.tokenTag(token)) {
         .identifier, .builtin => |tag| {
@@ -496,21 +499,20 @@ fn prepareCompletionLoc(tree: *const Ast, source_index: usize) offsets.Loc {
             std.debug.assert(token_loc.start <= source_index and source_index <= token_loc.end);
             return offsets.identifierIndexToLoc(tree.source, token_loc.start, if (tag == .builtin) .name else .full);
         },
-        .colon => return fallback_loc,
-        else => {
-            const token_start = tree.tokenStart(token);
+        else => |token_tag| {
+            if (token_tag != .invalid and !ast.isKeyword(token_tag))
+                return fallback_loc;
 
-            var start: usize, var end: usize = start: {
+            const start: usize, var end: usize = start: {
+                const token_start = tree.tokenStart(token);
                 if (std.mem.startsWith(u8, tree.source[token_start..], "@\"")) {
                     break :start .{ token_start, token_start + 2 };
                 } else if (std.mem.startsWith(u8, tree.source[token_start..], "@") or std.mem.startsWith(u8, tree.source[token_start..], ".")) {
-                    if (token_start + 1 < source_index) return fallback_loc;
                     break :start .{ token_start + 1, token_start + 1 };
                 } else {
                     break :start .{ token_start, token_start };
                 }
             };
-            start = @min(start, source_index);
             end = @max(end, source_index);
 
             while (end < tree.source.len and offsets.isSymbolChar(tree.source[end])) {

tests/lsp_features/completion.zig

@@ -4295,6 +4295,54 @@ test "insert replace behaviour - file system completions" {
     // zig fmt: on
 }
 
+test "insert replace behaviour - expression inside parens/braces/brackets" {
+    try testCompletionTextEdit(.{
+        .source =
+        \\const foo = 5;
+        \\const bar = foo(<cursor>);
+        ,
+        .label = "foo",
+        .expected_insert_line = "const bar = foo(foo);",
+        .expected_replace_line = "const bar = foo(foo);",
+    });
+    try testCompletionTextEdit(.{
+        .source =
+        \\const foo = 5;
+        \\const bar = foo(f<cursor>oo);
+        ,
+        .label = "foo",
+        .expected_insert_line = "const bar = foo(foooo);",
+        .expected_replace_line = "const bar = foo(foo);",
+    });
+    try testCompletionTextEdit(.{
+        .source =
+        \\const foo = 5;
+        \\const bar = foo(<cursor>foo);
+        ,
+        .label = "foo",
+        .expected_insert_line = "const bar = foo(foofoo);",
+        .expected_replace_line = "const bar = foo(foo);",
+    });
+    try testCompletionTextEdit(.{
+        .source =
+        \\const foo = 5;
+        \\const bar = foo{<cursor>};
+        ,
+        .label = "foo",
+        .expected_insert_line = "const bar = foo{foo};",
+        .expected_replace_line = "const bar = foo{foo};",
+    });
+    try testCompletionTextEdit(.{
+        .source =
+        \\const foo = 5;
+        \\const bar = foo[<cursor>];
+        ,
+        .label = "foo",
+        .expected_insert_line = "const bar = foo[foo];",
+        .expected_replace_line = "const bar = foo[foo];",
+    });
+}
+
 test "generic function with @This() as self param" {
     try testCompletion(
         \\const Foo = struct {