lsp: suggest closing tags

Author: kristoff-it

src/cli/lsp.zig

@@ -531,6 +531,7 @@ pub fn @"textDocument/completion"(
                 },
             },
             .commitCharacters = &.{" >"},
+            .preselect = cpl.label[0] == '/',
         };
     }
 

src/html/Ast.zig

@@ -16,6 +16,7 @@ const Attribute = @import("Attribute.zig");
 
 const log = std.log.scoped(.@"html/ast");
 const fmtlog = std.log.scoped(.@"html/ast/fmt");
+const cpllog = std.log.scoped(.@"html/ast/completions");
 
 has_syntax_errors: bool,
 language: Language,
@@ -1433,7 +1434,9 @@ pub fn completions(
     offset: u32,
 ) ![]const Completion {
     for (ast.errors) |err| {
-        if (err.tag != .token or offset != err.main_location.start) continue;
+        if (err.tag != .token or
+            offset < err.main_location.start or
+            offset > err.main_location.end) continue;
 
         var idx = offset;
         while (idx > 0) {
@@ -1445,27 +1448,27 @@ pub fn completions(
             }
         } else return &.{};
 
-        log.debug("completions before check", .{});
+        cpllog.debug("completions before check", .{});
         const parent_idx = err.node_idx;
         const parent_node = ast.nodes[parent_idx];
         if ((!parent_node.kind.isElement() and
             parent_node.kind != .root) or
             parent_node.kind == .svg or
             parent_node.kind == .math) return &.{};
 
-        log.debug("completions past check", .{});
+        cpllog.debug("completions past check", .{});
 
         const e = Element.all.get(parent_node.kind);
-        log.debug("===== completions content: {t}", .{parent_node.kind});
+        cpllog.debug("===== completions content: {t}", .{parent_node.kind});
         return e.completions(arena, ast, src, parent_idx, offset, .content);
     }
 
     const node_idx = ast.findNodeTagsIdx(offset);
-    log.debug("===== completions: attrs node: {}", .{node_idx});
+    cpllog.debug("===== completions: attrs node: {}", .{node_idx});
     if (node_idx == 0) return &.{};
 
     const n = ast.nodes[node_idx];
-    log.debug("===== node: {any}", .{n});
+    cpllog.debug("===== node: {any}", .{n});
     if (!n.kind.isElement()) return &.{};
     if (offset >= n.open.end) return &.{};
 

src/html/Element.zig

@@ -552,10 +552,10 @@ pub inline fn completions(
     offset: u32,
     mode: CompletionMode,
 ) ![]const Ast.Completion {
-    switch (mode) {
-        .attrs => {
+    const children = switch (mode) {
+        .attrs => blk: {
             var stt = ast.nodes[node_idx].startTagIterator(src, ast.language);
-            return Attribute.completions(
+            break :blk try Attribute.completions(
                 arena,
                 src,
                 &stt,
@@ -564,37 +564,59 @@ pub inline fn completions(
             );
         },
         .content => content: switch (element.content) {
-            .custom => |custom| return custom.completions(
+            .custom => |custom| try custom.completions(
                 arena,
                 ast,
                 src,
                 node_idx,
                 offset,
             ),
             .model => continue :content .{ .simple = .{} },
-            .simple => |simple| return simpleCompletions(
+            .simple => |simple| try simpleCompletions(
                 arena,
                 &.{},
                 ast.nodes[node_idx].model.content,
                 element.meta.content_reject,
                 simple,
             ),
-            .anything => {
+            .anything => blk: {
                 const start: usize = @intFromEnum(Kind.___) + 1;
                 const all_elems = all.values[start..];
-                const anything: [all_elems.len]Ast.Completion = comptime blk: {
+                const anything: [all_elems.len]Ast.Completion = comptime a: {
                     var anything: [all_elems.len]Ast.Completion = undefined;
                     for (all_elems, &anything) |in, *out| out.* = .{
                         .label = @tagName(in.tag),
                         .desc = in.desc,
                     };
-                    break :blk anything;
+                    break :a anything;
                 };
 
-                return &anything;
+                break :blk &anything;
             },
         },
+    };
+
+    var result: std.ArrayList(Ast.Completion) = .empty;
+
+    var ancestor_idx = node_idx;
+    while (ancestor_idx != 0) {
+        const ancestor = ast.nodes[ancestor_idx];
+        if (!ancestor.isClosed()) {
+            const name = ancestor.span(src).slice(src);
+            const slashed = try std.fmt.allocPrint(arena, "/{s}", .{name});
+            try result.append(arena, .{
+                .label = slashed,
+                .value = if (src[offset -| 1] == '/') name else slashed,
+                .desc = "",
+            });
+            break;
+        }
+        ancestor_idx = ancestor.parent_idx;
     }
+
+    try result.ensureTotalCapacityPrecise(arena, result.items.len + children.len);
+    result.appendSliceAssumeCapacity(children);
+    return result.items;
 }
 
 pub fn simpleCompletions(