lsp: introduce full element completions

when selecting a completion list entry for an html element, we now also
generate "></elem>".

this commit also fixes a regression in nesting validation where we failed
to run validations for certain nested elements

Author: kristoff-it

editors/vscode/.vscode/test.html

@@ -22,15 +22,15 @@ pub fn logFn(
     comptime format: []const u8,
     args: anytype,
 ) void {
-    switch (scope) {
-        .root, .super_lsp, .@"html/ast/fmt" => {},
-        else => return,
-    }
-    // inline for (build_options.enabled_scopes) |es| {
-    //     if (comptime std.mem.eql(u8, es, @tagName(scope))) {
-    //         break;
-    //     }
-    // } else return;
+    // switch (scope) {
+    //     .root, .super_lsp, .@"html/ast" => {},
+    //     else => return,
+    // }
+    inline for (build_options.enabled_scopes) |es| {
+        if (comptime std.mem.eql(u8, es, @tagName(scope))) {
+            break;
+        }
+    } else return;
 
     const l = log_file orelse return;
     const scope_prefix = "(" ++ @tagName(scope) ++ "): ";

src/cli/logging.zig

@@ -523,9 +523,23 @@ pub fn @"textDocument/completion"(
     const completions = try doc.html.completions(arena, doc.src, @intCast(offset));
     const items = try arena.alloc(lsp.types.CompletionItem, completions.len);
     for (items, completions) |*it, cpl| {
+        log.debug("label = '{s}' desc = '{s}'", .{ cpl.label, cpl.desc });
+        const insert_text = if (cpl.value) |v| blk: {
+            if (cpl.kind != .element_open) break :blk v;
+            var idx = offset;
+            const has_closing_bracket = while (idx < doc.src.len) : (idx += 1) {
+                switch (doc.src[idx]) {
+                    else => {},
+                    '\n' => break false,
+                    '>' => break true,
+                }
+            } else false;
+            if (has_closing_bracket) break :blk v[0..cpl.label.len];
+            break :blk v;
+        } else null;
         it.* = .{
             .label = cpl.label,
-            .insertText = cpl.value,
+            .insertText = insert_text,
             .documentation = if (cpl.desc.len == 0) null else .{
                 .MarkupContent = .{
                     .kind = .markdown,
@@ -534,6 +548,7 @@ pub fn @"textDocument/completion"(
             },
             .commitCharacters = &.{" >"},
             .preselect = cpl.label[0] == '/',
+            .insertTextFormat = if (cpl.kind == .element_open) .Snippet else null,
         };
     }
 

src/cli/lsp.zig

@@ -344,7 +344,7 @@ pub const Error = struct {
                             .first_or_last => "first or last",
                         }},
                     ),
-                    .missing_ancestor => |e| w.print("missing ancestor: {t}", .{e}),
+                    .missing_ancestor => |e| w.print("missing ancestor: <{t}>", .{e}),
                     .missing_child => |e| w.print("missing child: <{t}>", .{e}),
                     .duplicate_child => |dc| {
                         try w.print("duplicate child", .{});
@@ -1439,11 +1439,6 @@ pub fn validateNesting(
             .text,
             .doctype,
             => {
-                if (std.debug.runtime_safety and n.kind.isElement()) {
-                    const element: Element = elements.get(n.kind);
-                    assert(element.attributes != .manual);
-                }
-
                 var next = n;
                 node_idx = while (true) {
                     if (next.next_idx != 0) break next.next_idx;
@@ -1468,6 +1463,11 @@ pub fn validateNesting(
 
         if (n.kind == .template) try seen_ids_stack.append(gpa, .empty);
 
+        if (n.first_child_idx != 0) {
+            node_idx = n.first_child_idx;
+            continue;
+        }
+
         var next = n;
         node_idx = while (true) {
             if (next.kind == .template) {
@@ -1485,6 +1485,9 @@ pub const Completion = struct {
     label: []const u8,
     desc: []const u8,
     value: ?[]const u8 = null,
+    // This value is used by the lsp to know how to interpret
+    // the value field of this list of suggestions.
+    kind: enum { attribute, element_open, element_close } = .attribute,
 };
 
 pub fn completions(
@@ -2117,23 +2120,24 @@ test "fuzz" {
     const generator = @import("../generator/html.zig");
     const Context = struct {
         arena: *std.heap.ArenaAllocator,
-        gpa: Allocator,
         out: *Writer,
         fn testOne(ctx: @This(), input: []const u8) anyerror!void {
             _ = ctx.arena.reset(.retain_capacity);
+            const gpa = ctx.arena.allocator();
 
             var in: Reader = .fixed(input);
-            var out: Writer.Allocating = .init(ctx.gpa);
-            generator.generate(ctx.gpa, &in, &out.writer) catch |err| {
+            var out: Writer.Allocating = .init(gpa);
+            generator.generate(gpa, &in, &out.writer) catch |err| {
                 if (err == error.Skip) return;
                 return err;
             };
 
-            std.debug.print("--begin--\n{s}\n\n", .{out.written()});
+            log.debug("--begin--\n{s}\n\n", .{out.written()});
+
+            const ast: Ast = try .init(gpa, out.written(), .html, false);
 
-            const ast: Ast = try .init(ctx.gpa, out.written(), .html, false);
-            // _ = ast;
-            var devnull: Writer.Discarding = .init(&.{});
+            var bufnull: [4096]u8 = undefined;
+            var devnull: Writer.Discarding = .init(&bufnull);
             if (!ast.has_syntax_errors) {
                 try ast.render(out.written(), &devnull.writer);
             }
@@ -2149,7 +2153,6 @@ test "fuzz" {
     var out = std.fs.File.stdout().writer(&buf);
     try std.testing.fuzz(Context{
         .arena = &arena,
-        .gpa = arena.allocator(),
         .out = &out.interface,
     }, Context.testOne, .{});
 }

src/html/Ast.zig

@@ -575,71 +575,85 @@ pub inline fn completions(
     offset: u32,
     mode: CompletionMode,
 ) ![]const Ast.Completion {
-    const children = switch (mode) {
-        .attrs => blk: {
+    switch (mode) {
+        .attrs => {
             var stt = ast.nodes[node_idx].startTagIterator(src, ast.language);
-            break :blk try Attribute.completions(
+            return Attribute.completions(
                 arena,
                 src,
                 &stt,
                 element.tag,
                 offset,
             );
         },
-        .content => content: switch (element.content) {
-            .custom => |custom| try custom.completions(
-                arena,
-                ast,
-                src,
-                node_idx,
-                offset,
-            ),
-            .model => continue :content .{ .simple = .{} },
-            .simple => |simple| try simpleCompletions(
-                arena,
-                &.{},
-                ast.nodes[node_idx].model.content,
-                element.meta.content_reject,
-                simple,
-            ),
-            .anything => blk: {
-                const start: usize = @intFromEnum(Kind.___) + 1;
-                const all_elems = all.values[start..];
-                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 :a anything;
-                };
+        .content => {
+            const children = content: switch (element.content) {
+                .custom => |custom| try custom.completions(
+                    arena,
+                    ast,
+                    src,
+                    node_idx,
+                    offset,
+                ),
+                .model => continue :content .{ .simple = .{} },
+                .simple => |simple| try simpleCompletions(
+                    arena,
+                    &.{},
+                    ast.nodes[node_idx].model.content,
+                    element.meta.content_reject,
+                    simple,
+                ),
+                .anything => {
+                    // const start: usize = @intFromEnum(Kind.___) + 1;
+                    // const all_elems = all.values[start..];
+                    // 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 :a anything;
+                    // };
+
+                    // break :content &anything;
+                    break :content all_completions.values[8..];
+                },
+            };
 
-                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);
+                    log.debug("open ancestor = {any}, open = '{s}'\n", .{ ancestor, name });
+                    const slashed = try std.fmt.allocPrint(arena, "/{s}>", .{name});
+                    var idx = offset;
+                    const has_slash: u32 = @intFromBool(src[offset -| 1] == '/');
+                    const has_closing_bracket: u32 = while (idx < src.len) : (idx += 1) {
+                        switch (src[idx]) {
+                            else => {},
+                            '\n' => break 0,
+                            '>' => break 1,
+                        }
+                    } else 1;
+                    try result.append(arena, .{
+                        .label = slashed[0 .. slashed.len - 1],
+                        .value = slashed[has_slash .. slashed.len - has_closing_bracket],
+                        .desc = "Close the last open element.",
+                        .kind = .element_close,
+                    });
+                    break;
+                }
+                ancestor_idx = ancestor.parent_idx;
+            }
 
-    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;
+        },
     }
-
-    try result.ensureTotalCapacityPrecise(arena, result.items.len + children.len);
-    result.appendSliceAssumeCapacity(children);
-    return result.items;
 }
 
 pub fn simpleCompletions(
@@ -655,10 +669,7 @@ pub fn simpleCompletions(
         all.values.len - @intFromEnum(Kind.___),
     );
 
-    for (prefix) |p| list.appendAssumeCapacity(.{
-        .label = @tagName(p),
-        .desc = all.get(p).desc,
-    });
+    for (prefix) |p| list.appendAssumeCapacity(all_completions.get(p));
 
     const start: usize = @intFromEnum(Kind.___) + 1;
     outer: for (all.values[start..], start..) |e, idx| {
@@ -680,19 +691,13 @@ pub fn simpleCompletions(
 
         const child_cs = e.meta.categories_superset;
         if (parent_content.overlaps(child_cs)) {
-            list.appendAssumeCapacity(.{
-                .label = @tagName(child_kind),
-                .desc = e.desc,
-            });
+            list.appendAssumeCapacity(all_completions.get(child_kind));
             continue :outer;
         }
 
         for (simple.extra_children) |ec| {
             if (ec == child_kind) {
-                list.appendAssumeCapacity(.{
-                    .label = @tagName(child_kind),
-                    .desc = e.desc,
-                });
+                list.appendAssumeCapacity(all_completions.get(child_kind));
                 continue :outer;
             }
         }
@@ -720,6 +725,22 @@ pub const elements: KindMap = blk: {
     break :blk .initComptime(keys);
 };
 
+pub const all_completions = blk: {
+    var ac: std.EnumArray(Ast.Kind, Ast.Completion) = undefined;
+
+    const fields = std.meta.fields(Ast.Kind)[8..];
+    assert(std.mem.eql(u8, fields[0].name, "a"));
+    for (ac.values[8..], fields, all.values[8..]) |*completion, f, elem| {
+        completion.* = .{
+            .label = f.name,
+            .value = f.name ++ "$1>$0</" ++ f.name ++ ">",
+            .desc = elem.desc,
+            .kind = .element_open,
+        };
+    }
+    break :blk ac;
+};
+
 const temp: Element = .{
     .tag = .div,
     .model = .{

src/html/Element.zig

@@ -634,18 +634,13 @@ fn completionsContent(
         }
     }
 
-    const source = comptime Element.all.get(.source);
-    const track = comptime Element.all.get(.track);
+    const source = comptime Element.all_completions.get(.source);
+    const track = comptime Element.all_completions.get(.track);
 
     switch (state) {
         .source => switch (kind_after_cursor) {
-            .source => return &.{
-                .{ .label = @tagName(source.tag), .desc = source.desc },
-            },
-            .track => return &.{
-                .{ .label = @tagName(source.tag), .desc = source.desc },
-                .{ .label = @tagName(track.tag), .desc = track.desc },
-            },
+            .source => return &.{source},
+            .track => return &.{ source, track },
             else => return Element.simpleCompletions(
                 arena,
                 &.{ .source, .track },
@@ -656,9 +651,7 @@ fn completionsContent(
         },
 
         .track => switch (kind_after_cursor) {
-            .track => return &.{
-                .{ .label = @tagName(track.tag), .desc = track.desc },
-            },
+            .track => return &.{track},
             else => return Element.simpleCompletions(
                 arena,
                 &.{.track},

src/html/elements/audio_video.zig

@@ -111,7 +111,7 @@ fn completionsContent(
     if (has_span) return &.{};
 
     return &.{
-        .{ .label = "col", .desc = comptime Element.all.get(.col).desc },
-        .{ .label = "template", .desc = comptime Element.all.get(.template).desc },
+        comptime Element.all_completions.get(.col),
+        comptime Element.all_completions.get(.template),
     };
 }