wip

kristoff-it · kristoff-it · commit 2add4b538220 · 2025-09-17T19:21:12.000+02:00
diff --git a/build.zig b/build.zig
@@ -22,6 +22,7 @@ pub fn build(b: *std.Build) !void {
     const superhtml = b.addModule("superhtml", .{
         .root_source_file = b.path("src/root.zig"),
         .target = target,
+        .optimize = optimize,
     });
     superhtml.addImport("scripty", scripty.module("scripty"));
     superhtml.addImport("tracy", tracy.module("tracy"));
diff --git a/src/cli/check.zig b/src/cli/check.zig
@@ -3,7 +3,7 @@ const super = @import("superhtml");
 
 const FileType = enum { html, super };
 
-pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
+pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !noreturn {
     const cmd = Command.parse(args);
     var any_error = false;
     switch (cmd.mode) {
@@ -64,6 +64,7 @@ pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
     if (any_error) {
         std.process.exit(1);
     }
+    std.process.exit(0);
 }
 
 fn checkDir(
diff --git a/src/cli/fmt.zig b/src/cli/fmt.zig
@@ -3,49 +3,49 @@ const super = @import("superhtml");
 
 const FileType = enum { html, super };
 
-pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
+pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !noreturn {
     const cmd = Command.parse(args);
-    var any_error = false;
+
+    var errors = false;
     switch (cmd.mode) {
         .stdin => {
             var fr = std.fs.File.stdin().reader(&.{});
             var aw: std.Io.Writer.Allocating = .init(gpa);
             _ = try fr.interface.streamRemaining(&aw.writer);
             const in_bytes = try aw.toOwnedSliceSentinel(0);
 
-            const out_bytes = try fmtHtml(gpa, null, in_bytes, cmd.strict);
-
-            try std.fs.File.stdout().writeAll(out_bytes);
+            const result = try fmtHtml(gpa, null, in_bytes, cmd.strict);
+            try std.fs.File.stdout().writeAll(result.bytes);
+            errors |= result.errors;
         },
         .stdin_super => {
             var fr = std.fs.File.stdin().reader(&.{});
             var aw: std.Io.Writer.Allocating = .init(gpa);
             _ = try fr.interface.streamRemaining(&aw.writer);
             const in_bytes = try aw.toOwnedSliceSentinel(0);
 
-            const out_bytes = try fmtSuper(gpa, null, in_bytes, cmd.strict);
-            try std.fs.File.stdout().writeAll(out_bytes);
+            const result = try fmtSuper(gpa, null, in_bytes, cmd.strict);
+            try std.fs.File.stdout().writeAll(result.bytes);
+            errors |= result.errors;
         },
         .paths => |paths| {
             // checkFile will reset the arena at the end of each call
             var arena_impl = std.heap.ArenaAllocator.init(gpa);
             for (paths) |path| {
-                formatFile(
+                errors |= formatFile(
                     &arena_impl,
                     cmd.check,
                     std.fs.cwd(),
                     path,
                     path,
-                    &any_error,
                     cmd.strict,
                 ) catch |err| switch (err) {
                     error.IsDir, error.AccessDenied => {
-                        formatDir(
+                        errors |= formatDir(
                             gpa,
                             &arena_impl,
                             cmd.check,
                             path,
-                            &any_error,
                             cmd.strict,
                         ) catch |dir_err| {
                             std.debug.print("Error walking dir '{s}': {s}\n", .{
@@ -54,6 +54,7 @@ pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
                             });
                             std.process.exit(1);
                         };
+                        continue;
                     },
                     else => {
                         std.debug.print("Error while accessing '{s}': {s}\n", .{
@@ -66,39 +67,38 @@ pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
         },
     }
 
-    if (any_error) {
-        std.process.exit(1);
-    }
+    std.process.exit(@intFromBool(errors));
 }
 
 fn formatDir(
     gpa: std.mem.Allocator,
     arena_impl: *std.heap.ArenaAllocator,
     check: bool,
     path: []const u8,
-    any_error: *bool,
     strict: bool,
-) !void {
+) !bool {
     var dir = try std.fs.cwd().openDir(path, .{ .iterate = true });
     defer dir.close();
     var walker = dir.walk(gpa) catch oom();
     defer walker.deinit();
+    var errors = false;
     while (try walker.next()) |item| {
         switch (item.kind) {
             .file => {
-                try formatFile(
+                errors |= try formatFile(
                     arena_impl,
                     check,
                     item.dir,
                     item.basename,
                     item.path,
-                    any_error,
                     strict,
                 );
             },
             else => {},
         }
     }
+
+    return errors;
 }
 
 fn formatFile(
@@ -107,9 +107,8 @@ fn formatFile(
     base_dir: std.fs.Dir,
     sub_path: []const u8,
     full_path: []const u8,
-    any_error: *bool,
     strict: bool,
-) !void {
+) !bool {
     defer _ = arena_impl.reset(.retain_capacity);
     const arena = arena_impl.allocator();
 
@@ -132,10 +131,10 @@ fn formatFile(
         if (std.mem.eql(u8, ext, ".shtml")) {
             break :blk .super;
         }
-        return;
+        return false;
     };
 
-    const out_bytes = switch (file_type) {
+    const result = switch (file_type) {
         .html => try fmtHtml(
             arena,
             full_path,
@@ -150,54 +149,64 @@ fn formatFile(
         ),
     };
 
-    if (std.mem.eql(u8, out_bytes, in_bytes)) return;
+    if (std.mem.eql(u8, result.bytes, in_bytes)) return result.errors;
 
     var stdout_writer = std.fs.File.stdout().writer(&.{});
     const stdout = &stdout_writer.interface;
     if (check) {
-        any_error.* = true;
         try stdout.print("{s}\n", .{full_path});
-        return;
+        return result.errors;
     }
 
     var af = try base_dir.atomicFile(sub_path, .{ .write_buffer = &.{} });
     defer af.deinit();
 
-    try af.file_writer.interface.writeAll(out_bytes);
+    try af.file_writer.interface.writeAll(result.bytes);
     try af.finish();
     try stdout.print("{s}\n", .{full_path});
+    return result.errors;
 }
 
+const Result = struct {
+    bytes: []const u8,
+    errors: bool,
+};
+
 pub fn fmtHtml(
     arena: std.mem.Allocator,
     path: ?[]const u8,
     code: [:0]const u8,
     strict: bool,
-) ![]const u8 {
+) !Result {
     const ast = try super.html.Ast.init(arena, code, .html, strict);
     if (ast.errors.len > 0) {
         var ew = std.fs.File.stderr().writer(&.{});
         try ast.printErrors(code, path, &ew.interface);
-        std.process.exit(1);
+        if (ast.has_syntax_errors) std.process.exit(1);
     }
 
-    return std.fmt.allocPrint(arena, "{f}", .{ast.formatter(code)});
+    return .{
+        .bytes = try std.fmt.allocPrint(arena, "{f}", .{ast.formatter(code)}),
+        .errors = ast.errors.len > 0,
+    };
 }
 
 fn fmtSuper(
     arena: std.mem.Allocator,
     path: ?[]const u8,
     code: [:0]const u8,
     strict: bool,
-) ![]const u8 {
+) !Result {
     const ast = try super.html.Ast.init(arena, code, .superhtml, strict);
     if (ast.errors.len > 0) {
         var ew = std.fs.File.stderr().writer(&.{});
         try ast.printErrors(code, path, &ew.interface);
-        std.process.exit(1);
     }
 
-    return std.fmt.allocPrint(arena, "{f}", .{ast.formatter(code)});
+    return .{
+        .bytes = try std.fmt.allocPrint(arena, "{f}", .{ast.formatter(code)}),
+        .errors = ast.errors.len > 0,
+    };
 }
 
 fn oom() noreturn {
diff --git a/src/cli/interface.zig b/src/cli/interface.zig
@@ -3,7 +3,7 @@ const super = @import("superhtml");
 
 const FileType = enum { html, super };
 
-pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
+pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !noreturn {
     const cmd = Command.parse(args);
     switch (cmd.mode) {
         .stdin => {
@@ -41,6 +41,8 @@ pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
             try std.fs.File.stdout().writeAll(out_bytes);
         },
     }
+
+    std.process.exit(0);
 }
 
 fn printInterfaceFromFile(
diff --git a/src/cli/logging.zig b/src/cli/logging.zig
@@ -23,7 +23,7 @@ pub fn logFn(
     args: anytype,
 ) void {
     switch (scope) {
-        .root, .super_lsp, .@"html/ast" => {},
+        .root, .super_lsp, .@"html/ast/fmt" => {},
         else => return,
     }
     // inline for (build_options.enabled_scopes) |es| {
diff --git a/src/cli/lsp.zig b/src/cli/lsp.zig
@@ -11,7 +11,7 @@ const logic = @import("lsp/logic.zig");
 
 const log = std.log.scoped(.super_lsp);
 
-pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
+pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !noreturn {
     _ = args;
 
     log.debug("SuperHTML LSP started!", .{});
@@ -36,6 +36,8 @@ pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {
         &handler,
         log.err,
     );
+
+    std.process.exit(0);
 }
 
 pub const Handler = @This();
diff --git a/src/html/Ast.zig b/src/html/Ast.zig
@@ -145,7 +145,7 @@ pub const Node = struct {
     next_idx: u32 = 0,
 
     kind: Kind,
-    self_closing: bool = false, // TODO fold into element tags
+    self_closing: bool,
     model: Element.Model,
 
     pub fn isClosed(n: Node) bool {
@@ -485,6 +485,7 @@ pub fn init(
             .categories = .none,
             .content = .all,
         },
+        .self_closing = false,
     });
 
     var tokenizer: Tokenizer = .{ .language = language };
@@ -509,6 +510,7 @@ pub fn init(
                         .categories = .none,
                         .content = .none,
                     },
+                    .self_closing = false,
                 };
 
                 switch (current.direction()) {
@@ -533,6 +535,7 @@ pub fn init(
                 .start_self,
                 => {
                     const name = tag.name.slice(src);
+                    const self_closing = tag.kind == .start_self;
                     var new: Node = node: switch (tag.kind) {
                         else => unreachable,
                         .start_self => {
@@ -572,6 +575,7 @@ pub fn init(
                                         .categories = .all,
                                         .content = .all,
                                     },
+                                    .self_closing = self_closing,
                                 };
                             },
                             .html => {
@@ -598,6 +602,7 @@ pub fn init(
                                         .open = tag.span,
                                         .kind = kind,
                                         .model = model,
+                                        .self_closing = self_closing,
                                     };
                                 } else if (std.mem.indexOfScalar(u8, name, '-') == null) {
                                     try errors.append(gpa, .{
@@ -614,6 +619,7 @@ pub fn init(
                                         .categories = .all,
                                         .content = .all,
                                     },
+                                    .self_closing = self_closing,
                                 };
                             },
                             .xml => break :node .{
@@ -623,6 +629,7 @@ pub fn init(
                                     .categories = .all,
                                     .content = .all,
                                 },
+                                .self_closing = self_closing,
                             },
                         },
                     };
@@ -842,6 +849,7 @@ pub fn init(
                         },
                         .content = .none,
                     },
+                    .self_closing = false,
                 };
 
                 switch (current.direction()) {
@@ -872,6 +880,7 @@ pub fn init(
                         .categories = .all,
                         .content = .none,
                     },
+                    .self_closing = false,
                 };
 
                 log.debug("comment => current ({any})", .{current.*});
@@ -915,6 +924,7 @@ pub fn init(
     // finalize tree
     while (current.kind != .root) {
         if (!current.isClosed()) {
+            has_syntax_errors = true;
             try errors.append(gpa, .{
                 .tag = .missing_end_tag,
                 .main_location = current.open,
@@ -1061,7 +1071,8 @@ pub fn render(ast: Ast, src: []const u8, w: *Writer) !void {
                     // else
                     // std.ascii.isWhitespace(src[current.open.end]);
 
-                    const open_was_vertical = std.ascii.isWhitespace(src[current.open.end]);
+                    const open_was_vertical = current.open.end < src.len and
+                        std.ascii.isWhitespace(src[current.open.end]);
                     if (open_was_vertical) {
                         try w.writeAll("\n");
                         for (0..indentation) |_| {
@@ -2065,10 +2076,14 @@ test "fuzz" {
             var in: Reader = .fixed(input);
             var out: Writer.Allocating = .init(ctx.gpa);
             try generator.generate(ctx.gpa, &in, &out.writer);
-            std.debug.print("{s}\n\n", .{out.written()});
+            std.debug.print("--begin--\n{s}\n\n", .{out.written()});
 
             const ast: Ast = try .init(ctx.gpa, out.written(), .html, false);
-            _ = ast;
+            // _ = ast;
+            var devnull: Writer.Discarding = .init(&.{});
+            if (!ast.has_syntax_errors) {
+                try ast.render(out.written(), &devnull.writer);
+            }
         }
     };
 

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ const super = @import("superhtml");`
`3`	`3`
`4`	`4`	`const FileType = enum { html, super };`
`5`	`5`
`6`		`-pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {`
	`6`	`+pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !noreturn {`
`7`	`7`	`const cmd = Command.parse(args);`
`8`	`8`	`var any_error = false;`
`9`	`9`	`switch (cmd.mode) {`
`@@ -64,6 +64,7 @@ pub fn run(gpa: std.mem.Allocator, args: []const []const u8) !void {`
`64`	`64`	`if (any_error) {`
`65`	`65`	`std.process.exit(1);`
`66`	`66`	`}`
	`67`	`+ std.process.exit(0);`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`fn checkDir(`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ pub fn logFn(`
`23`	`23`	`args: anytype,`
`24`	`24`	`) void {`
`25`	`25`	`switch (scope) {`
`26`		`- .root, .super_lsp, .@"html/ast" => {},`
	`26`	`+ .root, .super_lsp, .@"html/ast/fmt" => {},`
`27`	`27`	`else => return,`
`28`	`28`	`}`
`29`	`29`	`// inline for (build_options.enabled_scopes) \|es\| {`