Make C pointers require a keyword.

doc/langref.html.in

@@ -10971,11 +10971,7 @@ lib.addCSourceFile(.{ .file = .{ .path = "src/lib.c" }, .flags = &.{
       </p>
       {#code_begin|exe|cImport_builtin#}
       {#link_libc#}
-const c = @cImport({
-    // See https://github.com/ziglang/zig/issues/515
-    @cDefine("_NO_CRT_STDIO_INLINE", "1");
-    @cInclude("stdio.h");
-});
+const c = @cImport(@cInclude("stdio.h"));
 pub fn main() void {
     _ = c.printf("hello\n");
 }

lib/compiler_rt/os_version_check.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const testing = std.testing;
 const builtin = @import("builtin");

lib/std/fmt.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std.zig");
 const builtin = @import("builtin");
 

lib/std/mem.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std.zig");
 const builtin = @import("builtin");
 const debug = std.debug;

lib/std/os/linux/bpf/helpers.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("../../../std.zig");
 const kern = @import("kern.zig");
 

lib/std/zig/Ast.zig

@@ -16,6 +16,9 @@ mode: Mode = .zig,
 
 errors: []const Error,
 
+/// If `thisfileisautotranslatedfromc` is present at the top of the file.
+is_autotranslated: bool = false,
+
 pub const TokenIndex = u32;
 pub const ByteOffset = u32;
 
@@ -78,6 +81,7 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
         .extra_data = .{},
         .scratch = .{},
         .tok_i = 0,
+        .is_autotranslated = false,
     };
     defer parser.errors.deinit(gpa);
     defer parser.nodes.deinit(gpa);
@@ -102,6 +106,7 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
         .nodes = parser.nodes.toOwnedSlice(),
         .extra_data = try parser.extra_data.toOwnedSlice(gpa),
         .errors = try parser.errors.toOwnedSlice(gpa),
+        .is_autotranslated = parser.is_autotranslated,
     };
 }
 
@@ -465,6 +470,10 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
                 }),
             }
         },
+
+        .autotranslated_not_first_token => {
+            return stream.writeAll("thisfileisautotranslatedfromc must be the first token in the file");
+        },
     }
 }
 
@@ -2919,6 +2928,8 @@ pub const Error = struct {
 
         /// `expected_tag` is populated.
         expected_token,
+
+        autotranslated_not_first_token,
     };
 };
 

lib/std/zig/Parse.zig

@@ -11,6 +11,7 @@ errors: std.ArrayListUnmanaged(AstError),
 nodes: Ast.NodeList,
 extra_data: std.ArrayListUnmanaged(Node.Index),
 scratch: std.ArrayListUnmanaged(Node.Index),
+is_autotranslated: bool,
 
 const SmallSpan = union(enum) {
     zero_or_one: Node.Index,
@@ -368,6 +369,27 @@ fn parseContainerMembers(p: *Parse) !Members {
                 }
                 trailing = p.token_tags[p.tok_i - 1] == .semicolon;
             },
+            .keyword_autotranslated => {
+                const token = p.assertToken(.keyword_autotranslated);
+                p.expectSemicolon(.expected_semi_after_decl, false) catch |err| {
+                    switch (err) {
+                        error.OutOfMemory => return error.OutOfMemory,
+                        error.ParseError => continue,
+                    }
+                };
+
+                if (p.nodes.len != 1) {
+                    try p.warnMsg(.{
+                        .tag = .autotranslated_not_first_token,
+                        .token = token,
+                    });
+                    continue;
+                }
+
+                p.is_autotranslated = true;
+
+                trailing = p.token_tags[p.tok_i - 1] == .semicolon;
+            },
             .eof, .r_brace => {
                 if (doc_comment) |tok| {
                     try p.warnMsg(.{

lib/std/zig/c_builtins.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 
 pub inline fn __builtin_bswap16(val: u16) u16 {

lib/std/zig/c_translation.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const builtin = @import("builtin");
 const testing = std.testing;

lib/std/zig/render.zig

@@ -100,6 +100,20 @@ pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast, fixups: Fixups) Error!v
         try renderContainerDocComments(&r, 0);
     }
 
+    if (tree.is_autotranslated) {
+        // The token can either be index 0 or 1, depending on whether there's a doc
+        // comment before hand.
+        // There should be blank line between the space and the next thing.
+        // It emphasises the tokens presence.
+        if (tree.tokens.items(.tag)[0] == .container_doc_comment) {
+            try renderToken(&r, 1, .semicolon);
+        } else {
+            try renderToken(&r, 0, .semicolon);
+        }
+
+        try r.ais.insertNewline();
+    }
+
     if (tree.mode == .zon) {
         try renderExpression(
             &r,
@@ -122,7 +136,9 @@ fn renderMembers(r: *Render, members: []const Ast.Node.Index) Error!void {
     const container: Container = for (members) |member| {
         if (tree.fullContainerField(member)) |field| if (!field.ast.tuple_like) break .other;
     } else .tuple;
+
     try renderMember(r, container, members[0], .newline);
+
     for (members[1..]) |member| {
         try renderExtraNewline(r, member);
         try renderMember(r, container, member, .newline);

lib/std/zig/tokenizer.zig

@@ -59,6 +59,7 @@ pub const Token = struct {
         .{ "var", .keyword_var },
         .{ "volatile", .keyword_volatile },
         .{ "while", .keyword_while },
+        .{ "thisfileisautotranslatedfromc", .keyword_autotranslated },
     });
 
     pub fn getKeyword(bytes: []const u8) ?Tag {
@@ -188,6 +189,7 @@ pub const Token = struct {
         keyword_var,
         keyword_volatile,
         keyword_while,
+        keyword_autotranslated,
 
         pub fn lexeme(tag: Tag) ?[]const u8 {
             return switch (tag) {
@@ -315,6 +317,7 @@ pub const Token = struct {
                 .keyword_var => "var",
                 .keyword_volatile => "volatile",
                 .keyword_while => "while",
+                .keyword_autotranslated => "thisfileisautotranslatedfromc",
             };
         }
 

src/AstGen.zig

@@ -410,22 +410,23 @@ fn lvalExpr(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Ins
     const node_tags = tree.nodes.items(.tag);
     const main_tokens = tree.nodes.items(.main_token);
     switch (node_tags[node]) {
-        .root => unreachable,
-        .@"usingnamespace" => unreachable,
-        .test_decl => unreachable,
-        .global_var_decl => unreachable,
-        .local_var_decl => unreachable,
-        .simple_var_decl => unreachable,
-        .aligned_var_decl => unreachable,
-        .switch_case => unreachable,
-        .switch_case_inline => unreachable,
-        .switch_case_one => unreachable,
-        .switch_case_inline_one => unreachable,
-        .container_field_init => unreachable,
-        .container_field_align => unreachable,
-        .container_field => unreachable,
-        .asm_output => unreachable,
-        .asm_input => unreachable,
+        .root,
+        .@"usingnamespace",
+        .test_decl,
+        .global_var_decl,
+        .local_var_decl,
+        .simple_var_decl,
+        .aligned_var_decl,
+        .switch_case,
+        .switch_case_inline,
+        .switch_case_one,
+        .switch_case_inline_one,
+        .container_field_init,
+        .container_field_align,
+        .container_field,
+        .asm_output,
+        .asm_input,
+        => unreachable,
 
         .assign,
         .assign_destructure,
@@ -3725,6 +3726,21 @@ fn ptrType(
         return gz.astgen.failTok(ptr_info.allowzero_token.?, "C pointers always allow address zero", .{});
     }
 
+    if (ptr_info.size == .C and !gz.astgen.tree.is_autotranslated) {
+        return gz.astgen.failNodeNotes(
+            node,
+            "[*c] pointers are only allowed in auto-translated C code",
+            .{},
+            &[_]u32{
+                try gz.astgen.errNoteNode(
+                    node,
+                    "* and [*] pointers may be used where a [*c] pointer is expected",
+                    .{},
+                ),
+            },
+        );
+    }
+
     const source_offset = gz.astgen.source_offset;
     const source_line = gz.astgen.source_line;
     const source_column = gz.astgen.source_column;

src/Compilation.zig

@@ -4322,7 +4322,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8) !CImportResult {
         const formatted = try tree.render(comp.gpa);
         defer comp.gpa.free(formatted);
 
-        try out_zig_file.writeAll(formatted);
+        try out_zig_file.writer().print("thisfileisautotranslatedfromc;\n{s}", .{formatted});
 
         break :digest digest;
     } else man.final();

src/autodoc/render_source.zig

@@ -232,6 +232,7 @@ pub fn tokenizeAndPrintRaw(
             .keyword_allowzero,
             .keyword_while,
             .keyword_anytype,
+            .keyword_autotranslated,
             => {
                 try out.writeAll("<span class=\"tok-kw\">");
                 try writeEscaped(out, src[token.loc.start..token.loc.end]);

src/main.zig

@@ -4416,7 +4416,7 @@ fn cmdTranslateC(comp: *Compilation, arena: Allocator, fancy_output: ?*Compilati
         const formatted = try tree.render(comp.gpa);
         defer comp.gpa.free(formatted);
 
-        try zig_file.writeAll(formatted);
+        try zig_file.writer().print("thisfileisautotranslatedfromc;\n{s}", .{formatted});
 
         man.writeManifest() catch |err| warn("failed to write cache manifest: {s}", .{
             @errorName(err),

test/behavior/bugs/11995.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const testing = std.testing;
 const builtin = @import("builtin");

test/behavior/bugs/4328.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const expect = @import("std").testing.expect;
 const builtin = @import("builtin");
 

test/behavior/cast.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const builtin = @import("builtin");
 const std = @import("std");
 const assert = std.debug.assert;

test/behavior/comptime_memory.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const builtin = @import("builtin");
 const endian = builtin.cpu.arch.endian();

test/behavior/generics.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const builtin = @import("builtin");
 const testing = std.testing;

test/behavior/optional.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const builtin = @import("builtin");
 const std = @import("std");
 const testing = std.testing;

test/behavior/pointers.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const builtin = @import("builtin");
 const std = @import("std");
 const testing = std.testing;

test/behavior/slice.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const builtin = @import("builtin");
 const std = @import("std");
 const expect = std.testing.expect;

test/behavior/slice_sentinel_comptime.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 test "comptime slice-sentinel in bounds (unterminated)" {
     // array
     comptime {

test/behavior/threadlocal.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const builtin = @import("builtin");
 const expect = std.testing.expect;

test/behavior/type.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const builtin = @import("builtin");
 const Type = std.builtin.Type;

test/behavior/type_info.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const std = @import("std");
 const builtin = @import("builtin");
 const mem = std.mem;

test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 const Foo = struct { a: u32 };
 export fn a() void {
     const T = [*c]Foo;
@@ -9,6 +11,6 @@ export fn a() void {
 // backend=stage2
 // target=native
 //
-// :3:19: error: C pointers cannot point to non-C-ABI-compatible type 'tmp.Foo'
-// :3:19: note: only extern structs and ABI sized packed structs are extern compatible
-// :1:13: note: struct declared here
+// :5:19: error: C pointers cannot point to non-C-ABI-compatible type 'tmp.Foo'
+// :5:19: note: only extern structs and ABI sized packed structs are extern compatible
+// :3:13: note: struct declared here

test/cases/compile_errors/C_pointer_to_anyopaque.zig

@@ -1,3 +1,5 @@
+thisfileisautotranslatedfromc;
+
 export fn a() void {
     var x: *anyopaque = undefined;
     var y: [*c]anyopaque = x;
@@ -8,4 +10,4 @@ export fn a() void {
 // backend=stage2
 // target=native
 //
-// :3:16: error: C pointers cannot point to opaque types
+// :5:16: error: C pointers cannot point to opaque types

test/cases/compile_errors/autotranslated_not_first_token.zig

@@ -0,0 +1,12 @@
+export fn a() void {
+    const foo: [*c]u8 = undefined;
+    _ = foo;
+}
+
+thisfileisautotranslatedfromc;
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:1: error: thisfileisautotranslatedfromc must be the first token in the file