provide global error set completions inside error{...} (zigtools#2561)

Author: llogick

src/analysis.zig

@@ -4855,9 +4855,14 @@ pub const PositionContext = union(enum) {
 const StackState = struct {
     ctx: PositionContext,
     stack_id: StackId,
+
+    /// Indicates whether the current context is an ErrorSet definition, ie `error{...}`
+    pub fn isErrSetDef(self: StackState) bool {
+        return (self.stack_id == .brace and self.ctx == .global_error_set);
+    }
 };
 
-const StackId = enum { paren, bracket, global };
+const StackId = enum { paren, bracket, brace, global };
 
 fn peek(allocator: std.mem.Allocator, arr: *std.ArrayList(StackState)) !*StackState {
     if (arr.items.len == 0) {
@@ -4917,6 +4922,25 @@ pub fn getPositionContext(
         break;
     }
 
+    // Check if the previous line ends with a ',', ie a continuation - targets multiline ErrorSet definitions
+    var lloc = line_loc;
+    while (true) {
+        while (lloc.start > 0) {
+            if (tree.source[lloc.start] != '\n') lloc.start -= 1 else break;
+        } else break;
+        while (lloc.start > 0 and tree.source[lloc.start] == '\n') lloc.start -= 1;
+        if (lloc.start == 0) break;
+        lloc = offsets.lineLocAtIndex(tree.source, lloc.start);
+        // Check if it's a comment first
+        while (lloc.start > 0 and std.mem.startsWith(u8, std.mem.trimStart(u8, offsets.locToSlice(tree.source, lloc), " \t"), "//")) {
+            const prev_line_loc = offsets.lineLocAtIndex(tree.source, lloc.start - 1); // `- 1` => prev line's `\n`
+            lloc = prev_line_loc;
+        }
+        if (std.mem.endsWith(u8, std.mem.trimEnd(u8, offsets.locToSlice(tree.source, lloc), " \t\r\n"), ",")) continue;
+        line_loc.start = lloc.start;
+        break;
+    }
+
     var stack: std.ArrayList(StackState) = try .initCapacity(allocator, 8);
     defer stack.deinit(allocator);
     var should_do_lookahead = lookahead;
@@ -5013,7 +5037,9 @@ pub fn getPositionContext(
                     }
                 }
             },
-            .identifier => switch (curr_ctx.ctx) {
+            .identifier => if (curr_ctx.isErrSetDef()) {
+                // Intent is to skip everything between the `error{...}` braces
+            } else switch (curr_ctx.ctx) {
                 .enum_literal => curr_ctx.ctx = .{ .enum_literal = tokenLocAppend(curr_ctx.ctx.loc(tree).?, tok) },
                 .field_access => curr_ctx.ctx = .{ .field_access = tokenLocAppend(curr_ctx.ctx.loc(tree).?, tok) },
                 .label_access => |loc| curr_ctx.ctx = if (loc.start == loc.end)
@@ -5061,21 +5087,29 @@ pub fn getPositionContext(
                 };
                 try stack.append(allocator, .{ .ctx = .empty, .stack_id = stack_id });
             },
-            .l_bracket => try stack.append(allocator, .{ .ctx = .empty, .stack_id = .bracket }),
             .r_paren => {
                 // Do this manually, as .pop() sets `stack.items[stack.items.len - 1]` to `undefined` which currently curr_ctx points to
                 if (stack.items.len != 0) stack.items.len -= 1;
                 if (curr_ctx.stack_id != .paren) {
                     (try peek(allocator, &stack)).ctx = .empty;
                 }
             },
+            .l_bracket => try stack.append(allocator, .{ .ctx = .empty, .stack_id = .bracket }),
             .r_bracket => {
                 // Do this manually, as .pop() sets `stack.items[stack.items.len - 1]` to `undefined` which currently curr_ctx points to
                 if (stack.items.len != 0) stack.items.len -= 1;
                 if (curr_ctx.stack_id != .bracket) {
                     (try peek(allocator, &stack)).ctx = .empty;
                 }
             },
+            .l_brace => try stack.append(allocator, .{ .ctx = if (curr_ctx.ctx == .global_error_set) curr_ctx.ctx else .empty, .stack_id = .brace }),
+            .r_brace => {
+                // Do this manually, as .pop() sets `stack.items[stack.items.len - 1]` to `undefined` which currently curr_ctx points to
+                if (stack.items.len != 0) stack.items.len -= 1;
+                if (curr_ctx.stack_id != .brace) {
+                    (try peek(allocator, &stack)).ctx = .empty;
+                }
+            },
             .keyword_error => curr_ctx.ctx = .global_error_set,
             .number_literal => {
                 if (tok.loc.start <= source_index and tok.loc.end >= source_index) {
@@ -5099,7 +5133,13 @@ pub fn getPositionContext(
                 std.debug.assert(tree.tokenTag(current_token) == tag);
                 curr_ctx.ctx = .{ .keyword = current_token };
             },
-            .doc_comment, .container_doc_comment => curr_ctx.ctx = .comment,
+            .container_doc_comment => curr_ctx.ctx = .comment,
+            .doc_comment => {
+                if (!curr_ctx.isErrSetDef()) curr_ctx.ctx = .comment; // Intent is to skip everything between the `error{...}` braces
+            },
+            .comma => {
+                if (!curr_ctx.isErrSetDef()) curr_ctx.ctx = .empty; // Intent is to skip everything between the `error{...}` braces
+            },
             else => curr_ctx.ctx = .empty,
         }
 

tests/utility/position_context.zig

@@ -401,10 +401,9 @@ test "multi-line string literal" {
 }
 
 test "global error set" {
-    // TODO why is this a .var_access instead of a .global_error_set?
-    // try testContext(
-    //     \\fn foo() <cursor>error!void {
-    // , .global_error_set, .{});
+    try testContext(
+        \\fn foo() <cursor>error!void {
+    , .global_error_set, .{ .lookahead = true });
     try testContext(
         \\fn foo() erro<cursor>r!void {
     , .global_error_set, .{ .lookahead = true });
@@ -417,14 +416,25 @@ test "global error set" {
     try testContext(
         \\fn foo() error.<cursor>!void {
     , .global_error_set, .{});
-
-    // TODO this should probably also be .global_error_set
-    // try testContext(
-    //     \\fn foo() error{<cursor>}!void {
-    // , .global_error_set, .{});
-    // try testContext(
-    //     \\fn foo() error{OutOfMemory, <cursor>}!void {
-    // , .global_error_set, .{});
+    try testContext(
+        \\fn foo() error{<cursor>}!void {
+    , .global_error_set, .{});
+    try testContext(
+        \\fn foo() error{OutOfMemory, <cursor>}!void {
+    , .global_error_set, .{});
+    try testContext(
+        \\fn foo() error{
+        \\  OutOfMemory,
+        \\  <cursor>
+        \\}!void {
+    , .global_error_set, .{});
+    try testContext(
+        \\fn foo() error{
+        \\  /// Doc Comment
+        \\  OutOfMemory,
+        \\  <cursor>
+        \\}!void {
+    , .global_error_set, .{});
 }
 
 test "number literal" {