lsp: add code action and rename element tag support

code action for now only offers to fix unknown tag names to `div`.

rename symbol will let you rename the tag name of an element. if the
element has a closing tag, it will be renamed aswell.

we also support renaming erroneous end tags.

Author: kristoff-it

src/cli.zig

@@ -81,7 +81,7 @@ pub fn main() !void {
         fatalHelp();
     };
 
-    // if (cmd == .lsp) lsp_mode = true;
+    if (cmd == .lsp) lsp_mode = true;
 
     _ = switch (cmd) {
         .check => check_exe.run(gpa, args[2..]),

src/cli/logging.zig

@@ -38,7 +38,7 @@ pub fn logFn(
     defer std.debug.unlockStdErr();
 
     var buf: [1024]u8 = undefined;
-    var fw = l.writer(&buf);
+    var fw = l.writerStreaming(&buf);
     const w = &fw.interface;
     w.print(prefix ++ format ++ "\n", args) catch return;
     w.flush() catch return;
@@ -54,11 +54,13 @@ pub fn setup(gpa: std.mem.Allocator) void {
 }
 
 fn setupInternal(gpa: std.mem.Allocator) !void {
-    const cache_base = try folders.open(gpa, .cache, .{}) orelse return error.Failure;
-    try cache_base.makePath("super");
+    var cache_base = try folders.open(gpa, .cache, .{}) orelse return error.Failure;
+    errdefer cache_base.close();
 
-    const log_path = "superhtml.log";
+    const log_path = "superhtml.log1";
     const file = try cache_base.createFile(log_path, .{ .truncate = false });
+    errdefer file.close();
+
     const end = try file.getEndPos();
     try file.seekTo(end);
 

src/cli/lsp.zig

@@ -107,9 +107,13 @@ pub fn initialize(
             },
         },
 
-        // .completionProvider = .{
-        //     .triggerCharacters = &.{ "<", "/" },
-        // },
+        .codeActionProvider = .{ .bool = true },
+
+        .renameProvider = .{ .bool = true },
+
+        .completionProvider = .{
+            .triggerCharacters = &.{ "<", "/" },
+        },
 
         .documentFormattingProvider = .{ .bool = true },
     };
@@ -242,6 +246,182 @@ pub fn @"textDocument/formatting"(
     }});
 }
 
+pub fn @"textDocument/codeAction"(
+    self: *Handler,
+    arena: std.mem.Allocator,
+    request: types.CodeActionParams,
+) error{OutOfMemory}!lsp.ResultType("textDocument/codeAction") {
+    const doc = self.files.getPtr(request.textDocument.uri) orelse return null;
+    const offset = lsp.offsets.positionToIndex(
+        doc.src,
+        request.range.start,
+        self.offset_encoding,
+    );
+
+    if (!self.strict) return null;
+
+    for (doc.html.errors) |err| {
+        if (err.tag != .ast or err.tag.ast != .invalid_html_tag_name) continue;
+
+        const span = err.main_location;
+        if (span.start <= offset and span.end > offset) {
+            const edits = try arena.alloc(lsp.types.TextEdit, 2);
+            edits[0] = .{
+                .range = getRange(span, doc.src),
+                .newText = "div",
+            };
+
+            const edits_len: usize = if (err.node_idx != 0) blk: {
+                const node = doc.html.nodes[err.node_idx];
+                if (node.kind != .element) break :blk 1;
+
+                const close = node.close;
+                if (close.end < 2 or close.start > close.end - 2) break :blk 1;
+
+                edits[1] = .{
+                    .range = getRange(.{
+                        .start = close.start + 1,
+                        .end = close.end - 1,
+                    }, doc.src),
+                    .newText = "/div",
+                };
+
+                break :blk 2;
+            } else 1;
+
+            const result: lsp.ResultType("textDocument/codeAction") = &.{
+                .{
+                    .CodeAction = .{
+                        .title = "Replace with 'div'",
+                        .kind = .quickfix,
+                        .isPreferred = true,
+                        .edit = .{
+                            .changes = .{
+                                .map = try .init(
+                                    arena,
+                                    &.{request.textDocument.uri},
+                                    &.{edits[0..edits_len]},
+                                ),
+                            },
+                        },
+                    },
+                },
+            };
+
+            return try arena.dupe(@typeInfo(@TypeOf(result.?)).pointer.child, result.?);
+        }
+    }
+
+    return null;
+}
+
+pub fn @"textDocument/rename"(
+    self: *Handler,
+    arena: std.mem.Allocator,
+    request: types.RenameParams,
+) error{OutOfMemory}!lsp.ResultType("textDocument/rename") {
+    const doc = self.files.getPtr(request.textDocument.uri) orelse return null;
+    const offset = lsp.offsets.positionToIndex(
+        doc.src,
+        request.position,
+        self.offset_encoding,
+    );
+
+    const node_idx: u32 = for (doc.html.errors) |err| {
+        // Find erroneous end tags in the error list but also any other error that
+        // has a node associated that happens to match our offset.
+        const span = err.main_location;
+        if (span.start <= offset and span.end > offset) {
+            if (err.tag == .ast and err.tag.ast == .erroneous_end_tag) {
+                const edits = try arena.alloc(lsp.types.TextEdit, 1);
+                edits[0] = .{
+                    .range = getRange(span, doc.src),
+                    .newText = request.newName,
+                };
+                return .{
+                    .changes = .{
+                        .map = try .init(
+                            arena,
+                            &.{request.textDocument.uri},
+                            &.{edits},
+                        ),
+                    },
+                };
+            }
+            if (err.node_idx != 0) break err.node_idx;
+        }
+    } else blk: {
+        // No match found in the error list, must navigate the AST
+        if (doc.html.nodes.len < 2) return null;
+        var cur_idx: u32 = 1;
+        while (cur_idx != 0) {
+            const n = doc.html.nodes[cur_idx];
+            if (n.open.start <= offset and n.open.end > offset) {
+                break;
+            }
+            if (n.close.end != 0 and n.close.start <= offset and n.close.end > offset) {
+                break;
+            }
+
+            if (n.open.end <= offset and n.close.start > offset) {
+                cur_idx = n.first_child_idx;
+            } else {
+                cur_idx = n.next_idx;
+            }
+        }
+
+        break :blk cur_idx;
+    };
+
+    const node = doc.html.nodes[node_idx];
+    var edits: []lsp.types.TextEdit = undefined;
+    blk: switch (node.kind) {
+        else => return null,
+        .element => {
+            edits = try arena.alloc(lsp.types.TextEdit, 2);
+
+            const it = node.startTagIterator(doc.src, doc.language);
+            edits[0] = .{
+                .range = getRange(it.name_span, doc.src),
+                .newText = request.newName,
+            };
+
+            const close = node.close;
+            if (close.end < 2 or close.start > close.end - 2) {
+                edits = edits[0..1];
+                break :blk;
+            }
+
+            edits[1] = .{
+                .range = getRange(.{
+                    .start = close.start + 1,
+                    .end = close.end - 1,
+                }, doc.src),
+                .newText = try std.fmt.allocPrint(arena, "/{s}", .{request.newName}),
+            };
+        },
+        .element_void, .element_self_closing => {
+            edits = try arena.alloc(lsp.types.TextEdit, 1);
+
+            const it = node.startTagIterator(doc.src, doc.language);
+            edits[0] = .{
+                .range = getRange(it.name_span, doc.src),
+                .newText = request.newName,
+            };
+        },
+    }
+
+    return .{
+        .changes = .{
+            .map = try .init(
+                arena,
+                &.{request.textDocument.uri},
+                &.{edits},
+            ),
+        },
+    };
+}
+
 pub fn @"textDocument/completion"(
     self: *Handler,
     arena: std.mem.Allocator,

src/html/Ast.zig

@@ -291,6 +291,7 @@ pub const Error = struct {
         },
     },
     main_location: Span,
+    node_idx: u32, // 0 = missing node
 };
 
 language: Language,
@@ -407,6 +408,7 @@ pub fn init(
                                         .ast = .html_elements_cant_self_close,
                                     },
                                     .main_location = tag.name,
+                                    .node_idx = current_idx + 1,
                                 });
                             }
                             break :blk .element_self_closing;
@@ -431,6 +433,7 @@ pub fn init(
                                 .ast = .invalid_html_tag_name,
                             },
                             .main_location = tag.name,
+                            .node_idx = current_idx + 1,
                         });
                     }
 
@@ -464,6 +467,7 @@ pub fn init(
                                 .ast = .deprecated_and_unsupported,
                             },
                             .main_location = tag.name,
+                            .node_idx = current_idx,
                         });
                     }
 
@@ -501,6 +505,7 @@ pub fn init(
                                                 .start = attr.name.start,
                                                 .end = attr.name.end,
                                             },
+                                            .node_idx = current_idx,
                                         });
                                     }
                                 },
@@ -515,6 +520,7 @@ pub fn init(
                                 .ast = .erroneous_end_tag,
                             },
                             .main_location = tag.name,
+                            .node_idx = 0,
                         });
                         continue;
                     }
@@ -538,6 +544,7 @@ pub fn init(
                             try errors.append(.{
                                 .tag = .{ .ast = .erroneous_end_tag },
                                 .main_location = tag.name,
+                                .node_idx = 0,
                             });
                             break;
                         }
@@ -587,6 +594,7 @@ pub fn init(
                                     try errors.append(.{
                                         .tag = .{ .ast = .missing_end_tag },
                                         .main_location = cur_name,
+                                        .node_idx = current_idx,
                                     });
                                 }
 
@@ -661,6 +669,7 @@ pub fn init(
                         .token = pe.tag,
                     },
                     .main_location = pe.span,
+                    .node_idx = current_idx,
                 });
             },
         }
@@ -672,9 +681,11 @@ pub fn init(
             try errors.append(.{
                 .tag = .{ .ast = .missing_end_tag },
                 .main_location = current.open,
+                .node_idx = current_idx,
             });
         }
 
+        current_idx = current.parent_idx;
         current = &nodes.items[current.parent_idx];
     }
 

src/root.zig

@@ -94,7 +94,7 @@ pub const Language = enum {
 };
 pub const max_size = 4 * 1024 * 1024 * 1024;
 
-const Range = struct {
+pub const Range = struct {
     start: Pos,
     end: Pos,