stage0-specific changes

lib/std/zig/parser_test.zig

@@ -4,6 +4,11 @@ const print = std.debug.print;
 const io = std.io;
 const maxInt = std.math.maxInt;
 
+const zig0 = if (@hasDecl(@import("root"), "zig0"))
+    @import("root").zig0
+else
+    struct { pub const enabled = false; };
+
 test "zig fmt: remove extra whitespace at start and end of file with comment between" {
     try testTransform(
         \\
@@ -6386,6 +6391,17 @@ test "ampersand" {
 var fixed_buffer_mem: [100 * 1024]u8 = undefined;
 
 fn testParse(source: [:0]const u8, allocator: mem.Allocator, anything_changed: *bool) ![]u8 {
+    // Also test C parser if available
+    if (zig0.enabled) {
+        var c_tree = zig0.c.astParse(source.ptr, @intCast(source.len));
+        defer zig0.c.astDeinit(&c_tree);
+        var zig0_tree = try zig0.zigAst(allocator, c_tree);
+        defer zig0_tree.deinit(allocator);
+        var ref_tree = try std.zig.Ast.parse(allocator, source, .zig);
+        defer ref_tree.deinit(allocator);
+        try zig0.expectAstConsistent(zig0_tree, ref_tree, source);
+    }
+
     var buffer: [64]u8 = undefined;
     const stderr = std.debug.lockStderrWriter(&buffer);
     defer std.debug.unlockStderrWriter();
@@ -6441,6 +6457,17 @@ fn testCanonical(source: [:0]const u8) !void {
 const Error = std.zig.Ast.Error.Tag;
 
 fn testError(source: [:0]const u8, expected_errors: []const Error) !void {
+    // Also test C parser error detection
+    if (zig0.enabled) {
+        var c_tree = zig0.c.astParse(source.ptr, @intCast(source.len));
+        defer zig0.c.astDeinit(&c_tree);
+        if (expected_errors.len == 0) {
+            try std.testing.expect(!c_tree.has_error);
+        } else {
+            try std.testing.expect(c_tree.has_error);
+        }
+    }
+
     var tree = try std.zig.Ast.parse(std.testing.allocator, source, .zig);
     defer tree.deinit(std.testing.allocator);
 

lib/std/zig/tokenizer.zig

@@ -1,4 +1,9 @@
-const std = @import("../std.zig");
+const std = @import("std");
+
+const zig0 = if (@hasDecl(@import("root"), "zig0"))
+    @import("root").zig0
+else
+    struct { pub const enabled = false; };
 
 pub const Token = struct {
     tag: Tag,
@@ -1707,6 +1712,17 @@ test "fuzzable properties upheld" {
 }
 
 fn testTokenize(source: [:0]const u8, expected_token_tags: []const Token.Tag) !void {
+    // Also test C tokenizer if available
+    if (zig0.enabled) {
+        var ctokenizer = zig0.c.tokenizerInit(source.ptr, @intCast(source.len));
+        for (expected_token_tags) |expected_token_tag| {
+            const token = zig0.c.tokenizerNext(&ctokenizer);
+            try std.testing.expectEqual(expected_token_tag, zig0.zigToken(token.tag));
+        }
+        const last_token = zig0.c.tokenizerNext(&ctokenizer);
+        try std.testing.expectEqual(Token.Tag.eof, zig0.zigToken(last_token.tag));
+    }
+
     var tokenizer = Tokenizer.init(source);
     for (expected_token_tags) |expected_token_tag| {
         const token = tokenizer.next();

lib/std/zig/zig0_test.zig

@@ -0,0 +1,6 @@
+pub const zig0 = @import("zig0_bridge");
+
+test {
+    _ = @import("parser_test.zig");
+    _ = @import("tokenizer.zig");
+}