Make translate-c use intermediate AST

CMakeLists.txt

@@ -578,6 +578,7 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/src/windows_sdk.zig"
     "${CMAKE_SOURCE_DIR}/src/zir.zig"
     "${CMAKE_SOURCE_DIR}/src/zir_sema.zig"
+    "${CMAKE_SOURCE_DIR}/src/translate_c/ast.zig"
 )
 
 if(MSVC)

lib/std/zig/parser_test.zig

@@ -3669,12 +3669,12 @@ test "zig fmt: hexadeciaml float literals with underscore separators" {
     );
 }
 
-//test "zig fmt: C var args" {
-//    try testCanonical(
-//        \\pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
-//        \\
-//    );
-//}
+test "zig fmt: C var args" {
+   try testCanonical(
+       \\pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
+       \\
+   );
+}
 
 //test "zig fmt: Only indent multiline string literals in function calls" {
 //    try testCanonical(

lib/std/zig/render.zig

@@ -550,14 +550,11 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
 
         .builtin_call_two, .builtin_call_two_comma => {
             if (datas[node].lhs == 0) {
-                const params = [_]ast.Node.Index{};
-                return renderBuiltinCall(ais, tree, main_tokens[node], &params, space);
+                return renderBuiltinCall(ais, tree, main_tokens[node], &.{}, space);
             } else if (datas[node].rhs == 0) {
-                const params = [_]ast.Node.Index{datas[node].lhs};
-                return renderBuiltinCall(ais, tree, main_tokens[node], &params, space);
+                return renderBuiltinCall(ais, tree, main_tokens[node], &.{datas[node].lhs}, space);
             } else {
-                const params = [_]ast.Node.Index{ datas[node].lhs, datas[node].rhs };
-                return renderBuiltinCall(ais, tree, main_tokens[node], &params, space);
+                return renderBuiltinCall(ais, tree, main_tokens[node], &.{ datas[node].lhs, datas[node].rhs }, space);
             }
         },
         .builtin_call, .builtin_call_comma => {
@@ -1311,7 +1308,7 @@ fn renderFnProto(ais: *Ais, tree: ast.Tree, fn_proto: ast.full.FnProto, space: S
                 .r_paren => break,
                 .comma => {
                     try renderToken(ais, tree, last_param_token, .space); // ,
-                    last_param_token += 1;
+                    continue;
                 },
                 else => {}, // Parameter type without a name.
             }

src/Compilation.zig

@@ -1334,7 +1334,7 @@ pub fn update(self: *Compilation) !void {
         self.c_object_work_queue.writeItemAssumeCapacity(entry.key);
     }
 
-    const use_stage1 = build_options.is_stage1 and self.bin_file.options.use_llvm;
+    const use_stage1 = build_options.omit_stage2 or build_options.is_stage1 and self.bin_file.options.use_llvm;
     if (!use_stage1) {
         if (self.bin_file.options.module) |module| {
             module.compile_log_text.shrinkAndFree(module.gpa, 0);

src/astgen.zig

@@ -2664,8 +2664,11 @@ fn identifier(
         return mod.failNode(scope, ident, "TODO implement '_' identifier", .{});
     }
 
-    if (getSimplePrimitiveValue(ident_name)) |typed_value| {
-        const result = try addZIRInstConst(mod, scope, src, typed_value);
+    if (simple_types.get(ident_name)) |val_tag| {
+        const result = try addZIRInstConst(mod, scope, src, TypedValue{
+            .ty = Type.initTag(.type),
+            .val = Value.initTag(val_tag),
+        });
         return rvalue(mod, scope, rl, result);
     }
 
@@ -3325,42 +3328,33 @@ fn callExpr(
     return rvalue(mod, scope, rl, result);
 }
 
-fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {
-    const simple_types = std.ComptimeStringMap(Value.Tag, .{
-        .{ "u8", .u8_type },
-        .{ "i8", .i8_type },
-        .{ "isize", .isize_type },
-        .{ "usize", .usize_type },
-        .{ "c_short", .c_short_type },
-        .{ "c_ushort", .c_ushort_type },
-        .{ "c_int", .c_int_type },
-        .{ "c_uint", .c_uint_type },
-        .{ "c_long", .c_long_type },
-        .{ "c_ulong", .c_ulong_type },
-        .{ "c_longlong", .c_longlong_type },
-        .{ "c_ulonglong", .c_ulonglong_type },
-        .{ "c_longdouble", .c_longdouble_type },
-        .{ "f16", .f16_type },
-        .{ "f32", .f32_type },
-        .{ "f64", .f64_type },
-        .{ "f128", .f128_type },
-        .{ "c_void", .c_void_type },
-        .{ "bool", .bool_type },
-        .{ "void", .void_type },
-        .{ "type", .type_type },
-        .{ "anyerror", .anyerror_type },
-        .{ "comptime_int", .comptime_int_type },
-        .{ "comptime_float", .comptime_float_type },
-        .{ "noreturn", .noreturn_type },
-    });
-    if (simple_types.get(name)) |tag| {
-        return TypedValue{
-            .ty = Type.initTag(.type),
-            .val = Value.initTag(tag),
-        };
-    }
-    return null;
-}
+pub const simple_types = std.ComptimeStringMap(Value.Tag, .{
+    .{ "u8", .u8_type },
+    .{ "i8", .i8_type },
+    .{ "isize", .isize_type },
+    .{ "usize", .usize_type },
+    .{ "c_short", .c_short_type },
+    .{ "c_ushort", .c_ushort_type },
+    .{ "c_int", .c_int_type },
+    .{ "c_uint", .c_uint_type },
+    .{ "c_long", .c_long_type },
+    .{ "c_ulong", .c_ulong_type },
+    .{ "c_longlong", .c_longlong_type },
+    .{ "c_ulonglong", .c_ulonglong_type },
+    .{ "c_longdouble", .c_longdouble_type },
+    .{ "f16", .f16_type },
+    .{ "f32", .f32_type },
+    .{ "f64", .f64_type },
+    .{ "f128", .f128_type },
+    .{ "c_void", .c_void_type },
+    .{ "bool", .bool_type },
+    .{ "void", .void_type },
+    .{ "type", .type_type },
+    .{ "anyerror", .anyerror_type },
+    .{ "comptime_int", .comptime_int_type },
+    .{ "comptime_float", .comptime_float_type },
+    .{ "noreturn", .noreturn_type },
+});
 
 fn nodeMayNeedMemoryLocation(start_node: *ast.Node, scope: *Scope) bool {
     var node = start_node;

src/clang.zig

@@ -127,6 +127,9 @@ pub const APSInt = opaque {
 
     pub const getNumWords = ZigClangAPSInt_getNumWords;
     extern fn ZigClangAPSInt_getNumWords(*const APSInt) c_uint;
+
+    pub const lessThanEqual = ZigClangAPSInt_lessThanEqual;
+    extern fn ZigClangAPSInt_lessThanEqual(*const APSInt, rhs: u64) bool;
 };
 
 pub const ASTContext = opaque {
@@ -270,12 +273,12 @@ pub const CompoundAssignOperator = opaque {
 
 pub const CompoundStmt = opaque {
     pub const body_begin = ZigClangCompoundStmt_body_begin;
-    extern fn ZigClangCompoundStmt_body_begin(*const CompoundStmt) const_body_iterator;
+    extern fn ZigClangCompoundStmt_body_begin(*const CompoundStmt) ConstBodyIterator;
 
     pub const body_end = ZigClangCompoundStmt_body_end;
-    extern fn ZigClangCompoundStmt_body_end(*const CompoundStmt) const_body_iterator;
+    extern fn ZigClangCompoundStmt_body_end(*const CompoundStmt) ConstBodyIterator;
 
-    pub const const_body_iterator = [*]const *Stmt;
+    pub const ConstBodyIterator = [*]const *Stmt;
 };
 
 pub const ConditionalOperator = opaque {};
@@ -407,7 +410,7 @@ pub const Expr = opaque {
     pub const getBeginLoc = ZigClangExpr_getBeginLoc;
     extern fn ZigClangExpr_getBeginLoc(*const Expr) SourceLocation;
 
-    pub const EvaluateAsConstantExpr = ZigClangExpr_EvaluateAsConstantExpr;
+    pub const evaluateAsConstantExpr = ZigClangExpr_EvaluateAsConstantExpr;
     extern fn ZigClangExpr_EvaluateAsConstantExpr(*const Expr, *ExprEvalResult, Expr_ConstExprUsage, *const ASTContext) bool;
 };