wip export rewrite

1 files changed, 535 insertions, 287 deletions

diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 8dbb8171c2..8aa57c4468 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -1,253 +1,328 @@
 const tests = @import("tests.zig");
 
 pub fn addCases(cases: &tests.CompileErrorContext) {
+    cases.add("wrong return type for main",
+        \\pub fn main() { }
+    , ".tmp_source.zig:1:15: error: expected return type of main to be '%void', instead is 'void'");
+
+    cases.add("double ?? on main return value",
+        \\pub fn main() -> ??void {
+        \\}
+    , ".tmp_source.zig:1:18: error: expected return type of main to be '%void', instead is '??void'");
+
+    cases.add("setting a section on an extern variable",
+        \\extern var foo: i32 section(".text2");
+        \\extern fn entry() -> i32 {
+        \\    return foo;
+        \\}
+        \\comptime { @export("entry", entry); }
+    ,
+        ".tmp_source.zig:1:29: error: cannot set section of external variable 'foo'");
+
+    cases.add("setting a section on a local variable",
+        \\extern fn entry() -> i32 {
+        \\    var foo: i32 section(".text2") = 1234;
+        \\    return foo;
+        \\}
+        \\comptime { @export("entry", entry); }
+    ,
+        ".tmp_source.zig:2:26: error: cannot set section of local variable 'foo'");
+
+    cases.add("setting a section on an extern fn",
+        \\extern fn foo() section(".text2");
+        \\extern fn entry() {
+        \\    foo();
+        \\}
+        \\comptime { @export("entry", entry); }
+    ,
+        ".tmp_source.zig:1:25: error: cannot set section of external function 'foo'");
+
+    cases.add("wrong types given to exportWithLinkage",
+        \\extern fn entry() { }
+        \\comptime {
+        \\    @exportWithLinkage("entry", entry, u32(1234));
+        \\}
+    ,
+        ".tmp_source.zig:3:43: error: expected type 'GlobalLinkage', found 'u32'");
+
     cases.add("implicit semicolon - block statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    {}
         \\    var good = {};
         \\    ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - block expr",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = {};
         \\    var good = {};
         \\    _ = {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - comptime statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    comptime {}
         \\    var good = {};
         \\    comptime ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - comptime expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = comptime {};
         \\    var good = {};
         \\    _ = comptime {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - defer",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    defer {}
         \\    var good = {};
         \\    defer ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: expected token ';', found 'var'");
 
     cases.add("implicit semicolon - if statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    if(true) {}
         \\    var good = {};
         \\    if(true) ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = if(true) {};
         \\    var good = {};
         \\    _ = if(true) {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if-else statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    if(true) {} else {}
         \\    var good = {};
         \\    if(true) ({}) else ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if-else expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = if(true) {} else {};
         \\    var good = {};
         \\    _ = if(true) {} else {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if-else-if statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    if(true) {} else if(true) {}
         \\    var good = {};
         \\    if(true) ({}) else if(true) ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if-else-if expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = if(true) {} else if(true) {};
         \\    var good = {};
         \\    _ = if(true) {} else if(true) {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if-else-if-else statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    if(true) {} else if(true) {} else {}
         \\    var good = {};
         \\    if(true) ({}) else if(true) ({}) else ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - if-else-if-else expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = if(true) {} else if(true) {} else {};
         \\    var good = {};
         \\    _ = if(true) {} else if(true) {} else {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - test statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    if (foo()) |_| {}
         \\    var good = {};
         \\    if (foo()) |_| ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - test expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = if (foo()) |_| {};
         \\    var good = {};
         \\    _ = if (foo()) |_| {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - while statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    while(true) {}
         \\    var good = {};
         \\    while(true) ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - while expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = while(true) {};
         \\    var good = {};
         \\    _ = while(true) {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - while-continue statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    while(true):({}) {}
         \\    var good = {};
         \\    while(true):({}) ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - while-continue expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = while(true):({}) {};
         \\    var good = {};
         \\    _ = while(true):({}) {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - for statement",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    for(foo()) {}
         \\    var good = {};
         \\    for(foo()) ({})
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("implicit semicolon - for expression",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    _ = for(foo()) {};
         \\    var good = {};
         \\    _ = for(foo()) {}
         \\    var bad = {};
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:5: error: invalid token: 'var'");
 
     cases.add("multiple function definitions",
         \\fn a() {}
         \\fn a() {}
-        \\export fn entry() { a(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { a(); }
     , ".tmp_source.zig:2:1: error: redefinition of 'a'");
 
     cases.add("unreachable with return",
         \\fn a() -> noreturn {return;}
-        \\export fn entry() { a(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { a(); }
     , ".tmp_source.zig:1:21: error: expected type 'noreturn', found 'void'");
 
     cases.add("control reaches end of non-void function",
         \\fn a() -> i32 {}
-        \\export fn entry() { _ = a(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { _ = a(); }
     , ".tmp_source.zig:1:15: error: expected type 'i32', found 'void'");
 
     cases.add("undefined function call",
-        \\export fn a() {
+        \\extern fn a() {
         \\    b();
         \\}
+        \\comptime {@export("a", a);}
     , ".tmp_source.zig:2:5: error: use of undeclared identifier 'b'");
 
     cases.add("wrong number of arguments",
-        \\export fn a() {
+        \\extern fn a() {
         \\    b(1);
         \\}
         \\fn b(a: i32, b: i32, c: i32) { }
+        \\comptime {@export("a", a);}
     , ".tmp_source.zig:2:6: error: expected 3 arguments, found 1");
 
     cases.add("invalid type",
         \\fn a() -> bogus {}
-        \\export fn entry() { _ = a(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { _ = a(); }
     , ".tmp_source.zig:1:11: error: use of undeclared identifier 'bogus'");
 
     cases.add("pointer to unreachable",
         \\fn a() -> &noreturn {}
-        \\export fn entry() { _ = a(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { _ = a(); }
     , ".tmp_source.zig:1:12: error: pointer to unreachable not allowed");
 
     cases.add("unreachable code",
-        \\export fn a() {
+        \\extern fn a() {
         \\    return;
         \\    b();
         \\}
         \\
         \\fn b() {}
+        \\comptime {@export("a", a);}
     , ".tmp_source.zig:3:5: error: unreachable code");
 
     cases.add("bad import",
         \\const bogus = @import("bogus-does-not-exist.zig");
-        \\export fn entry() { bogus.bogo(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { bogus.bogo(); }
     , ".tmp_source.zig:1:15: error: unable to find 'bogus-does-not-exist.zig'");
 
     cases.add("undeclared identifier",
-        \\export fn a() {
+        \\extern fn a() {
         \\    b +
         \\    c
         \\}
+        \\comptime {@export("a", a);}
     ,
             ".tmp_source.zig:2:5: error: use of undeclared identifier 'b'",
             ".tmp_source.zig:3:5: error: use of undeclared identifier 'c'");
@@ -255,99 +330,114 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
     cases.add("parameter redeclaration",
         \\fn f(a : i32, a : i32) {
         \\}
-        \\export fn entry() { f(1, 2); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { f(1, 2); }
     , ".tmp_source.zig:1:15: error: redeclaration of variable 'a'");
 
     cases.add("local variable redeclaration",
-        \\export fn f() {
+        \\extern fn f() {
         \\    const a : i32 = 0;
         \\    const a = 0;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:5: error: redeclaration of variable 'a'");
 
     cases.add("local variable redeclares parameter",
         \\fn f(a : i32) {
         \\    const a = 0;
         \\}
-        \\export fn entry() { f(1); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { f(1); }
     , ".tmp_source.zig:2:5: error: redeclaration of variable 'a'");
 
     cases.add("variable has wrong type",
-        \\export fn f() -> i32 {
+        \\extern fn f() -> i32 {
         \\    const a = c"a";
         \\    a
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:5: error: expected type 'i32', found '&const u8'");
 
     cases.add("if condition is bool, not int",
-        \\export fn f() {
+        \\extern fn f() {
         \\    if (0) {}
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:9: error: integer value 0 cannot be implicitly casted to type 'bool'");
 
     cases.add("assign unreachable",
-        \\export fn f() {
+        \\extern fn f() {
         \\    const a = return;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:5: error: unreachable code");
 
     cases.add("unreachable variable",
-        \\export fn f() {
+        \\extern fn f() {
         \\    const a: noreturn = {};
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:14: error: variable of type 'noreturn' not allowed");
 
     cases.add("unreachable parameter",
         \\fn f(a: noreturn) {}
-        \\export fn entry() { f(); }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() { f(); }
     , ".tmp_source.zig:1:9: error: parameter of type 'noreturn' not allowed");
 
     cases.add("bad assignment target",
-        \\export fn f() {
+        \\extern fn f() {
         \\    3 = 3;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:7: error: cannot assign to constant");
 
     cases.add("assign to constant variable",
-        \\export fn f() {
+        \\extern fn f() {
         \\    const a = 3;
         \\    a = 4;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:7: error: cannot assign to constant");
 
     cases.add("use of undeclared identifier",
-        \\export fn f() {
+        \\extern fn f() {
         \\    b = 3;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:5: error: use of undeclared identifier 'b'");
 
     cases.add("const is a statement, not an expression",
-        \\export fn f() {
+        \\extern fn f() {
         \\    (const a = 0);
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:6: error: invalid token: 'const'");
 
     cases.add("array access of undeclared identifier",
-        \\export fn f() {
+        \\extern fn f() {
         \\    i[i] = i[i];
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:5: error: use of undeclared identifier 'i'",
                  ".tmp_source.zig:2:12: error: use of undeclared identifier 'i'");
 
     cases.add("array access of non array",
-        \\export fn f() {
+        \\extern fn f() {
         \\    var bad : bool = undefined;
         \\    bad[bad] = bad[bad];
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:8: error: array access of non-array type 'bool'",
                  ".tmp_source.zig:3:19: error: array access of non-array type 'bool'");
 
     cases.add("array access with non integer index",
-        \\export fn f() {
+        \\extern fn f() {
         \\    var array = "aoeu";
         \\    var bad = false;
         \\    array[bad] = array[bad];
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:4:11: error: expected type 'usize', found 'bool'",
                  ".tmp_source.zig:4:24: error: expected type 'usize', found 'bool'");
 
@@ -356,7 +446,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn f() {
         \\    x = 1;
         \\}
-        \\export fn entry() { f(); }
+        \\extern fn entry() { f(); }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:7: error: cannot assign to constant");
 
 
@@ -365,29 +456,33 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    const x : i32 = if (b) { 1 };
         \\    const y = if (b) { i32(1) };
         \\}
-        \\export fn entry() { f(true); }
+        \\extern fn entry() { f(true); }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:30: error: integer value 1 cannot be implicitly casted to type 'void'",
                  ".tmp_source.zig:3:15: error: incompatible types: 'i32' and 'void'");
 
     cases.add("direct struct loop",
         \\const A = struct { a : A, };
-        \\export fn entry() -> usize { @sizeOf(A) }
+        \\extern fn entry() -> usize { @sizeOf(A) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:11: error: struct 'A' contains itself");
 
     cases.add("indirect struct loop",
         \\const A = struct { b : B, };
         \\const B = struct { c : C, };
         \\const C = struct { a : A, };
-        \\export fn entry() -> usize { @sizeOf(A) }
+        \\extern fn entry() -> usize { @sizeOf(A) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:11: error: struct 'A' contains itself");
 
     cases.add("invalid struct field",
         \\const A = struct { x : i32, };
-        \\export fn f() {
+        \\extern fn f() {
         \\    var a : A = undefined;
         \\    a.foo = 1;
         \\    const y = a.bar;
         \\}
+        \\comptime {@export("f", f);}
     ,
             ".tmp_source.zig:4:6: error: no member named 'foo' in struct 'A'",
             ".tmp_source.zig:5:16: error: no member named 'bar' in struct 'A'");
@@ -415,7 +510,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    y : i32,
         \\    z : i32,
         \\};
-        \\export fn f() {
+        \\extern fn f() {
         \\    const a = A {
         \\        .z = 1,
         \\        .y = 2,
@@ -423,6 +518,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        .z = 4,
         \\    };
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:11:9: error: duplicate field");
 
     cases.add("missing field in struct value expression",
@@ -431,7 +527,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    y : i32,
         \\    z : i32,
         \\};
-        \\export fn f() {
+        \\extern fn f() {
         \\    // we want the error on the '{' not the 'A' because
         \\    // the A could be a complicated expression
         \\    const a = A {
@@ -439,6 +535,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        .y = 2,
         \\    };
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:9:17: error: missing field: 'x'");
 
     cases.add("invalid field in struct value expression",
@@ -447,69 +544,79 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    y : i32,
         \\    z : i32,
         \\};
-        \\export fn f() {
+        \\extern fn f() {
         \\    const a = A {
         \\        .z = 4,
         \\        .y = 2,
         \\        .foo = 42,
         \\    };
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:10:9: error: no member named 'foo' in struct 'A'");
 
     cases.add("invalid break expression",
-        \\export fn f() {
+        \\extern fn f() {
         \\    break;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:5: error: break expression outside loop");
 
     cases.add("invalid continue expression",
-        \\export fn f() {
+        \\extern fn f() {
         \\    continue;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:5: error: continue expression outside loop");
 
     cases.add("invalid maybe type",
-        \\export fn f() {
+        \\extern fn f() {
         \\    if (true) |x| { }
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:9: error: expected nullable type, found 'bool'");
 
     cases.add("cast unreachable",
         \\fn f() -> i32 {
         \\    i32(return 1)
         \\}
-        \\export fn entry() { _ = f(); }
+        \\extern fn entry() { _ = f(); }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:8: error: unreachable code");
 
     cases.add("invalid builtin fn",
         \\fn f() -> @bogus(foo) {
         \\}
-        \\export fn entry() { _ = f(); }
+        \\extern fn entry() { _ = f(); }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:11: error: invalid builtin function: 'bogus'");
 
     cases.add("top level decl dependency loop",
         \\const a : @typeOf(b) = 0;
         \\const b : @typeOf(a) = 0;
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const c = a + b;
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:1: error: 'a' depends on itself");
 
     cases.add("noalias on non pointer param",
         \\fn f(noalias x: i32) {}
-        \\export fn entry() { f(1234); }
+        \\extern fn entry() { f(1234); }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:6: error: noalias on non-pointer parameter");
 
     cases.add("struct init syntax for array",
         \\const foo = []u16{.x = 1024,};
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:18: error: type '[]u16' does not support struct initialization syntax");
 
     cases.add("type variables must be constant",
         \\var foo = u8;
-        \\export fn entry() -> foo {
+        \\extern fn entry() -> foo {
         \\    return 1;
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:1: error: variable of type 'type' must be constant");
 
 
@@ -521,9 +628,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    var Bar : i32 = undefined;
         \\}
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    f(1234);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:4:6: error: redefinition of 'Foo'",
             ".tmp_source.zig:1:1: note: previous definition is here",
@@ -545,7 +653,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:8:5: error: enumeration value 'Number.Four' not handled in switch");
 
     cases.add("switch expression - duplicate enumeration prong",
@@ -565,7 +674,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:13:15: error: duplicate switch value",
       ".tmp_source.zig:10:15: note: other value is here");
 
@@ -587,7 +697,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:13:15: error: duplicate switch value",
       ".tmp_source.zig:10:15: note: other value is here");
 
@@ -599,9 +710,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        else => true,
         \\    };
         \\}
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    f(1234);
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:9: error: multiple else prongs in switch expression");
 
     cases.add("switch expression - non exhaustive integer prongs",
@@ -610,7 +722,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        0 => {},
         \\    }
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:5: error: switch must handle all possibilities");
 
@@ -623,7 +736,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        206 ... 255 => 3,
         \\    }
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:9: error: duplicate switch value",
         ".tmp_source.zig:5:14: note: previous value is here");
@@ -635,14 +749,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\}
         \\const y: u8 = 100;
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:5: error: else prong required when switching on type '&u8'");
 
     cases.add("global variable initializer must be constant expression",
         \\extern fn foo() -> i32;
         \\const x = foo();
-        \\export fn entry() -> i32 { x }
+        \\extern fn entry() -> i32 { x }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:11: error: unable to evaluate constant expression");
 
     cases.add("array concatenation with wrong type",
@@ -650,7 +766,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const derp = usize(1234);
         \\const a = derp ++ "foo";
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:11: error: expected array or C string literal, found 'usize'");
 
     cases.add("non compile time array concatenation",
@@ -658,12 +775,14 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    s ++ "foo"
         \\}
         \\var s: [10]u8 = undefined;
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:5: error: unable to evaluate constant expression");
 
     cases.add("@cImport with bogus include",
         \\const c = @cImport(@cInclude("bogus.h"));
-        \\export fn entry() -> usize { @sizeOf(@typeOf(c.bogo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(c.bogo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:11: error: C import failed",
                  ".h:1:10: note: 'bogus.h' file not found");
 
@@ -671,17 +790,20 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const x = 3;
         \\const y = &x;
         \\fn foo() -> &const i32 { y }
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:26: error: expected type '&const i32', found '&const (integer literal)'");
 
     cases.add("integer overflow error",
         \\const x : u8 = 300;
-        \\export fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:16: error: integer value 300 cannot be implicitly casted to type 'u8'");
 
     cases.add("incompatible number literals",
         \\const x = 2 == 2.0;
-        \\export fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:11: error: integer value 2 cannot be implicitly casted to type '(float literal)'");
 
     cases.add("missing function call param",
@@ -707,13 +829,15 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    const result = members[index]();
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:20:34: error: expected 1 arguments, found 0");
 
     cases.add("missing function name and param name",
         \\fn () {}
         \\fn f(i32) {}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:1:1: error: missing function name",
             ".tmp_source.zig:2:6: error: missing parameter name");
@@ -723,16 +847,20 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn a() -> i32 {0}
         \\fn b() -> i32 {1}
         \\fn c() -> i32 {2}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(fns)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(fns)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:21: error: expected type 'fn()', found 'fn() -> i32'");
 
     cases.add("extern function pointer mismatch",
         \\const fns = [](fn(i32)->i32){ a, b, c };
         \\pub fn a(x: i32) -> i32 {x + 0}
         \\pub fn b(x: i32) -> i32 {x + 1}
-        \\export fn c(x: i32) -> i32 {x + 2}
+        \\extern fn c(x: i32) -> i32 {x + 2}
+        \\
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(fns)) }
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(fns)) }
+        \\comptime {@export("entry", entry);}
+        \\comptime {@export("c", c);}
     , ".tmp_source.zig:1:37: error: expected type 'fn(i32) -> i32', found 'extern fn(i32) -> i32'");
 
 
@@ -740,14 +868,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const x : f64 = 1.0;
         \\const y : f32 = x;
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:17: error: expected type 'f32', found 'f64'");
 
 
     cases.add("colliding invalid top level functions",
         \\fn func() -> bogus {}
         \\fn func() -> bogus {}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(func)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(func)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:2:1: error: redefinition of 'func'",
             ".tmp_source.zig:1:14: error: use of undeclared identifier 'bogus'");
@@ -755,7 +885,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
 
     cases.add("bogus compile var",
         \\const x = @import("builtin").bogus;
-        \\export fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:29: error: no member named 'bogus' in '");
 
 
@@ -766,7 +897,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\var global_var: usize = 1;
         \\fn get() -> usize { global_var }
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(Foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(Foo)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:5:21: error: unable to evaluate constant expression",
             ".tmp_source.zig:2:12: note: called from here",
@@ -779,7 +911,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\};
         \\const x = Foo {.field = 1} + Foo {.field = 2};
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'");
 
 
@@ -789,10 +922,14 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const int_x = u32(1) / u32(0);
         \\const float_x = f32(1.0) / f32(0.0);
         \\
-        \\export fn entry1() -> usize { @sizeOf(@typeOf(lit_int_x)) }
-        \\export fn entry2() -> usize { @sizeOf(@typeOf(lit_float_x)) }
-        \\export fn entry3() -> usize { @sizeOf(@typeOf(int_x)) }
-        \\export fn entry4() -> usize { @sizeOf(@typeOf(float_x)) }
+        \\extern fn entry1() -> usize { @sizeOf(@typeOf(lit_int_x)) }
+        \\extern fn entry2() -> usize { @sizeOf(@typeOf(lit_float_x)) }
+        \\extern fn entry3() -> usize { @sizeOf(@typeOf(int_x)) }
+        \\extern fn entry4() -> usize { @sizeOf(@typeOf(float_x)) }
+        \\comptime {@export("entry1", entry1);}
+        \\comptime {@export("entry2", entry2);}
+        \\comptime {@export("entry3", entry3);}
+        \\comptime {@export("entry4", entry4);}
     ,
             ".tmp_source.zig:1:21: error: division by zero is undefined",
             ".tmp_source.zig:2:25: error: division by zero is undefined",
@@ -804,14 +941,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const foo = "a
         \\b";
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:13: error: newline not allowed in string literal");
 
     cases.add("invalid comparison for function pointers",
         \\fn foo() {}
         \\const invalid = foo > foo;
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(invalid)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(invalid)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:21: error: operator not allowed for type 'fn()'");
 
     cases.add("generic function instance with non-constant expression",
@@ -820,16 +959,18 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    return foo(a, b);
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(test1)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(test1)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:16: error: unable to evaluate constant expression");
 
     cases.add("goto jumping into block",
-        \\export fn f() {
+        \\extern fn f() {
         \\    {
         \\a_label:
         \\    }
         \\    goto a_label;
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:5:5: error: no label in scope named 'a_label'");
 
     cases.add("goto jumping past a defer",
@@ -840,20 +981,23 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\}
         \\fn derp(){}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:12: error: no label in scope named 'label'");
 
     cases.add("assign null to non-nullable pointer",
         \\const a: &u8 = null;
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:16: error: expected type '&u8', found '(null)'");
 
     cases.add("indexing an array of size zero",
         \\const array = []u8{};
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    const pointer = &array[0];
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:3:27: error: index 0 outside array of size 0");
 
     cases.add("compile time division by zero",
@@ -862,7 +1006,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    1 / x
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:3:7: error: division by zero is undefined",
             ".tmp_source.zig:1:14: note: called from here");
@@ -870,7 +1015,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
     cases.add("branch on undefined value",
         \\const x = if (undefined) true else false;
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(x)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:15: error: use of undefined value");
 
 
@@ -880,7 +1026,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    return fibbonaci(x - 1) + fibbonaci(x - 2);
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(seventh_fib_number)) }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(seventh_fib_number)) }
     ,
             ".tmp_source.zig:3:21: error: evaluation exceeded 1000 backwards branches",
             ".tmp_source.zig:3:21: note: called from here");
@@ -888,7 +1035,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
     cases.add("@embedFile with bogus file",
         \\const resource = @embedFile("bogus.txt");
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(resource)) }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(resource)) }
     , ".tmp_source.zig:1:29: error: unable to find '", "bogus.txt'");
 
     cases.add("non-const expression in struct literal outside function",
@@ -898,7 +1046,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const a = Foo {.x = get_it()};
         \\extern fn get_it() -> i32;
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(a)) }
     , ".tmp_source.zig:4:21: error: unable to evaluate constant expression");
 
     cases.add("non-const expression function call with struct return value outside function",
@@ -912,18 +1061,20 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\}
         \\var global_side_effect = false;
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(a)) }
     ,
             ".tmp_source.zig:6:24: error: unable to evaluate constant expression",
             ".tmp_source.zig:4:17: note: called from here");
 
     cases.add("undeclared identifier error should mark fn as impure",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    test_a_thing();
         \\}
         \\fn test_a_thing() {
         \\    bad_fn_call();
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:5:5: error: use of undeclared identifier 'bad_fn_call'");
 
     cases.add("illegal comparison of types",
@@ -938,14 +1089,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    *a == *b
         \\}
         \\
-        \\export fn entry1() -> usize { @sizeOf(@typeOf(bad_eql_1)) }
-        \\export fn entry2() -> usize { @sizeOf(@typeOf(bad_eql_2)) }
+        \\extern fn entry1() -> usize { @sizeOf(@typeOf(bad_eql_1)) }
+        \\extern fn entry2() -> usize { @sizeOf(@typeOf(bad_eql_2)) }
+        \\comptime {@export("entry1", entry1);}
+        \\comptime {@export("entry2", entry2);}
     ,
             ".tmp_source.zig:2:7: error: operator not allowed for type '[]u8'",
             ".tmp_source.zig:9:8: error: operator not allowed for type 'EnumWithData'");
 
     cases.add("non-const switch number literal",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    const x = switch (bar()) {
         \\        1, 2 => 1,
         \\        3, 4 => 2,
@@ -955,22 +1108,25 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn bar() -> i32 {
         \\    2
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:15: error: unable to infer expression type");
 
     cases.add("atomic orderings of cmpxchg - failure stricter than success",
         \\const AtomicOrder = @import("builtin").AtomicOrder;
-        \\export fn f() {
+        \\extern fn f() {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:4:72: error: failure atomic ordering must be no stricter than success");
 
     cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
         \\const AtomicOrder = @import("builtin").AtomicOrder;
-        \\export fn f() {
+        \\extern fn f() {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:4:49: error: success atomic ordering must be Monotonic or stricter");
 
     cases.add("negation overflow in function evaluation",
@@ -979,7 +1135,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    -x
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:3:5: error: negation caused overflow",
             ".tmp_source.zig:1:14: note: called from here");
@@ -990,7 +1147,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    a + b
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:3:7: error: operation caused overflow",
             ".tmp_source.zig:1:14: note: called from here");
@@ -1002,7 +1160,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    a - b
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:3:7: error: operation caused overflow",
             ".tmp_source.zig:1:14: note: called from here");
@@ -1013,7 +1172,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    a * b
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(y)) }
+        \\comptime {@export("entry", entry);}
     ,
             ".tmp_source.zig:3:7: error: operation caused overflow",
             ".tmp_source.zig:1:14: note: called from here");
@@ -1024,40 +1184,35 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    @truncate(i8, x)
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:19: error: expected signed integer type, found 'u32'");
 
     cases.add("%return in function with non error return type",
-        \\export fn f() {
+        \\extern fn f() {
         \\    %return something();
         \\}
         \\fn something() -> %void { }
+        \\comptime {@export("f", f);}
     ,
             ".tmp_source.zig:2:5: error: expected type 'void', found 'error'");
 
-    cases.add("wrong return type for main",
-        \\pub fn main() { }
-    , ".tmp_source.zig:1:15: error: expected return type of main to be '%void', instead is 'void'");
-
-    cases.add("double ?? on main return value",
-        \\pub fn main() -> ??void {
-        \\}
-    , ".tmp_source.zig:1:18: error: expected return type of main to be '%void', instead is '??void'");
-
     cases.add("invalid pointer for var type",
         \\extern fn ext() -> usize;
         \\var bytes: [ext()]u8 = undefined;
-        \\export fn f() {
+        \\extern fn f() {
         \\    for (bytes) |*b, i| {
         \\        *b = u8(i);
         \\    }
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:2:13: error: unable to evaluate constant expression");
 
     cases.add("export function with comptime parameter",
-        \\export fn foo(comptime x: i32, y: i32) -> i32{
+        \\extern fn foo(comptime x: i32, y: i32) -> i32{
         \\    x + y
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'");
 
     cases.add("extern function with comptime parameter",
@@ -1065,14 +1220,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn f() -> i32 {
         \\    foo(1, 2)
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'");
 
     cases.add("convert fixed size array to slice with invalid size",
-        \\export fn f() {
+        \\extern fn f() {
         \\    var array: [5]u8 = undefined;
         \\    var foo = ([]const u32)(array)[0];
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:28: error: unable to convert [5]u8 to []const u32: size mismatch");
 
     cases.add("non-pure function returns type",
@@ -1090,10 +1247,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\}
         \\
-        \\export fn function_with_return_type_type() {
+        \\extern fn function_with_return_type_type() {
         \\    var list: List(i32) = undefined;
         \\    list.length = 10;
         \\}
+        \\comptime {@export("function_with_return_type_type", function_with_return_type_type);}
     , ".tmp_source.zig:3:7: error: unable to evaluate constant expression",
         ".tmp_source.zig:16:19: note: called from here");
 
@@ -1102,7 +1260,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn f(m: []const u8) {
         \\    m.copy(u8, self[0..], m);
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:6: error: no member named 'copy' in '[]const u8'");
 
     cases.add("wrong number of arguments for method fn call",
@@ -1113,21 +1272,24 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\
         \\    foo.method(1, 2);
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(f)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:6:15: error: expected 2 arguments, found 3");
 
     cases.add("assign through constant pointer",
-        \\export fn f() {
+        \\extern fn f() {
         \\  var cstr = c"Hat";
         \\  cstr[0] = 'W';
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:11: error: cannot assign to constant");
 
     cases.add("assign through constant slice",
-        \\export fn f() {
+        \\extern fn f() {
         \\  var cstr: []const u8 = "Hat";
         \\  cstr[0] = 'W';
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:3:11: error: cannot assign to constant");
 
     cases.add("main function with bogus args type",
@@ -1138,7 +1300,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn foo(blah: []u8) {
         \\    for (blah) { }
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:5: error: for loop expression missing element parameter");
 
     cases.add("misspelled type with pointer only reference",
@@ -1171,7 +1334,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    var jd = JsonNode {.kind = JsonType.JSONArray , .jobject = JsonOA.JSONArray {jll} };
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:5:16: error: use of undeclared identifier 'JsonList'");
 
     cases.add("method call with first arg type primitive",
@@ -1185,11 +1349,12 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\};
         \\
-        \\export fn f() {
+        \\extern fn f() {
         \\    const derp = Foo.init(3);
         \\
         \\    derp.init();
         \\}
+        \\comptime {@export("f", f);}
     , ".tmp_source.zig:14:5: error: expected type 'i32', found '&const Foo'");
 
     cases.add("method call with first arg type wrong container",
@@ -1213,10 +1378,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    field: i32,
         \\};
         \\
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    var x = List.init(&global_allocator);
         \\    x.init();
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:23:5: error: expected type '&Allocator', found '&List'");
 
     cases.add("binary not on number literal",
@@ -1224,16 +1390,18 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const TINY_QUANTUM_SIZE = 1 << TINY_QUANTUM_SHIFT;
         \\var block_aligned_stuff: usize = (4 + TINY_QUANTUM_SIZE) & ~(TINY_QUANTUM_SIZE - 1);
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(block_aligned_stuff)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(block_aligned_stuff)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:60: error: unable to perform binary not operation on type '(integer literal)'");
 
     cases.addCase({
         const tc = cases.create("multiple files with private function error",
             \\const foo = @import("foo.zig");
             \\
-            \\export fn callPrivFunction() {
+            \\extern fn callPrivFunction() {
             \\    foo.privateFunction();
             \\}
+            \\comptime {@export("callPrivFunction", callPrivFunction);}
         ,
             ".tmp_source.zig:4:8: error: 'privateFunction' is private",
             "foo.zig:1:1: note: declared here");
@@ -1249,17 +1417,19 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const zero: i32 = 0;
         \\const a = zero{1};
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(a)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:11: error: expected type, found 'i32'");
 
     cases.add("assign to constant field",
         \\const Foo = struct {
         \\    field: i32,
         \\};
-        \\export fn derp() {
+        \\extern fn derp() {
         \\    const f = Foo {.field = 1234,};
         \\    f.field = 0;
         \\}
+        \\comptime {@export("derp", derp);}
     , ".tmp_source.zig:6:13: error: cannot assign to constant");
 
     cases.add("return from defer expression",
@@ -1277,7 +1447,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    return 0;
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(testTrickyDefer)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(testTrickyDefer)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:4:11: error: cannot return from defer expression");
 
     cases.add("attempt to access var args out of bounds",
@@ -1289,7 +1460,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    add(i32(1234))
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
     ,
             ".tmp_source.zig:2:19: error: index 1 outside argument list of size 1",
             ".tmp_source.zig:6:8: note: called from here");
@@ -1307,27 +1479,31 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    add(1, 2, 3, 4)
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(bar)) }
+        \\comptime {@export("entry", entry);}
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(bar)) }
     , ".tmp_source.zig:10:9: error: parameter of type '(integer literal)' requires comptime");
 
     cases.add("assign too big number to u16",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    var vga_mem: u16 = 0xB8000;
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:24: error: integer value 753664 cannot be implicitly casted to type 'u16'");
 
     cases.add("global variable alignment non power of 2",
         \\const some_data: [100]u8 align(3) = undefined;
-        \\export fn entry() -> usize { @sizeOf(@typeOf(some_data)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(some_data)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:32: error: alignment value 3 is not a power of 2");
 
     cases.add("function alignment non power of 2",
         \\extern fn foo() align(3);
-        \\export fn entry() { foo() }
+        \\extern fn entry() { foo() }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:1:23: error: alignment value 3 is not a power of 2");
 
     cases.add("compile log",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    comptime bar(12, "hi");
         \\}
         \\fn bar(a: i32, b: []const u8) {
@@ -1335,6 +1511,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    @compileLog("a", a, "b", b);
         \\    @compileLog("end");
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:5:5: error: found compile log statement",
         ".tmp_source.zig:2:17: note: called from here",
@@ -1358,7 +1535,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    return *x;
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:8:26: error: expected type '&const u3', found '&align(1:3:6) const u3'");
 
     cases.add("referring to a struct that is invalid",
@@ -1366,19 +1544,20 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Type: u8,
         \\};
         \\
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    comptime assert(@sizeOf(UsbDeviceRequest) == 0x8);
         \\}
         \\
         \\fn assert(ok: bool) {
         \\    if (!ok) unreachable;
         \\}
+        \\comptime {@export("foo", foo);}
     ,
             ".tmp_source.zig:10:14: error: unable to evaluate constant expression",
             ".tmp_source.zig:6:20: note: called from here");
 
     cases.add("control flow uses comptime var at runtime",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    comptime var i = 0;
         \\    while (i < 5) : (i += 1) {
         \\        bar();
@@ -1386,53 +1565,61 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\}
         \\
         \\fn bar() { }
+        \\comptime {@export("foo", foo);}
     ,
             ".tmp_source.zig:3:5: error: control flow attempts to use compile-time variable at runtime",
             ".tmp_source.zig:3:24: note: compile-time variable assigned here");
 
     cases.add("ignored return value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    bar();
         \\}
         \\fn bar() -> i32 { 0 }
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:8: error: expression value is ignored");
 
     cases.add("ignored assert-err-ok return value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    %%bar();
         \\}
         \\fn bar() -> %i32 { 0 }
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:5: error: expression value is ignored");
 
     cases.add("ignored statement value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    1;
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:5: error: expression value is ignored");
 
     cases.add("ignored comptime statement value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    comptime {1;}
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:15: error: expression value is ignored");
 
     cases.add("ignored comptime value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    comptime 1;
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:5: error: expression value is ignored");
 
     cases.add("ignored defered statement value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    defer {1;}
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:12: error: expression value is ignored");
 
     cases.add("ignored defered statement value",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    defer bar();
         \\}
         \\fn bar() -> %i32 { 0 }
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:2:14: error: expression value is ignored");
 
     cases.add("dereference an array",
@@ -1443,7 +1630,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    return (*out)[0..1];
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(pass)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(pass)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:4:5: error: attempt to dereference non pointer type '[10]u8'");
 
     cases.add("pass const ptr to mutable ptr fn",
@@ -1456,46 +1644,31 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    return true;
         \\}
         \\
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:4:19: error: expected type '&[]const u8', found '&const []const u8'");
 
-    cases.addCase({
-        const tc = cases.create("export collision",
-            \\const foo = @import("foo.zig");
-            \\
-            \\export fn bar() -> usize {
-            \\    return foo.baz;
-            \\}
-        ,
-            "foo.zig:1:8: error: exported symbol collision: 'bar'",
-            ".tmp_source.zig:3:8: note: other symbol is here");
-
-        tc.addSourceFile("foo.zig",
-            \\export fn bar() {}
-            \\pub const baz = 1234;
-        );
-
-        tc
-    });
-
     cases.add("pass non-copyable type by value to function",
         \\const Point = struct { x: i32, y: i32, };
         \\fn foo(p: Point) { }
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:11: error: type 'Point' is not copyable; cannot pass by value");
 
     cases.add("implicit cast from array to mutable slice",
         \\var global_array: [10]i32 = undefined;
         \\fn foo(param: []i32) {}
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    foo(global_array);
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:4:9: error: expected type '[]i32', found '[10]i32'");
 
     cases.add("ptrcast to non-pointer",
-        \\export fn entry(a: &i32) -> usize {
+        \\extern fn entry(a: &i32) -> usize {
         \\    return @ptrCast(usize, a);
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:2:21: error: expected pointer, found 'usize'");
 
     cases.add("too many error values to cast to small integer",
@@ -1504,7 +1677,8 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn foo(e: error) -> u2 {
         \\    return u2(e);
         \\}
-        \\export fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\extern fn entry() -> usize { @sizeOf(@typeOf(foo)) }
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:4:14: error: too many error values to fit in 'u2'");
 
     cases.add("asm at compile time",
@@ -1523,41 +1697,46 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
 
     cases.add("invalid member of builtin enum",
         \\const builtin = @import("builtin");
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const foo = builtin.Arch.x86;
         \\}
+        \\comptime {@export("entry", entry);}
     , ".tmp_source.zig:3:29: error: container 'Arch' has no member called 'x86'");
 
     cases.add("int to ptr of 0 bits",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    var x: usize = 0x1000;
         \\    var y: &void = @intToPtr(&void, x);
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:3:31: error: type '&void' has 0 bits and cannot store information");
 
     cases.add("@fieldParentPtr - non struct",
         \\const Foo = i32;
-        \\export fn foo(a: &i32) -> &Foo {
+        \\extern fn foo(a: &i32) -> &Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:3:28: error: expected struct type, found 'i32'");
 
     cases.add("@fieldParentPtr - bad field name",
         \\const Foo = struct {
         \\    derp: i32,
         \\};
-        \\export fn foo(a: &i32) -> &Foo {
+        \\extern fn foo(a: &i32) -> &Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:5:33: error: struct 'Foo' has no field 'a'");
 
     cases.add("@fieldParentPtr - field pointer is not pointer",
         \\const Foo = struct {
         \\    a: i32,
         \\};
-        \\export fn foo(a: i32) -> &Foo {
+        \\extern fn foo(a: i32) -> &Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:5:38: error: expected pointer, found 'i32'");
 
     cases.add("@fieldParentPtr - comptime field ptr not based on struct",
@@ -1587,18 +1766,20 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
 
     cases.add("@offsetOf - non struct",
         \\const Foo = i32;
-        \\export fn foo() -> usize {
+        \\extern fn foo() -> usize {
         \\    return @offsetOf(Foo, "a");
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:3:22: error: expected struct type, found 'i32'");
 
     cases.add("@offsetOf - bad field name",
         \\const Foo = struct {
         \\    derp: i32,
         \\};
-        \\export fn foo() -> usize {
+        \\extern fn foo() -> usize {
         \\    return @offsetOf(Foo, "a");
         \\}
+        \\comptime {@export("foo", foo);}
     , ".tmp_source.zig:5:27: error: struct 'Foo' has no field 'a'");
 
     cases.addExe("missing main fn in executable",
@@ -1611,38 +1792,22 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         "error: 'main' is private",
         ".tmp_source.zig:1:1: note: declared here");
 
-    cases.add("@setGlobalSection extern variable",
-        \\extern var foo: i32;
-        \\comptime {
-        \\    @setGlobalSection(foo, ".text2");
-        \\}
-    ,
-        ".tmp_source.zig:3:5: error: cannot set section of external variable 'foo'",
-        ".tmp_source.zig:1:8: note: declared here");
-
-    cases.add("@setGlobalSection extern fn",
-        \\extern fn foo();
-        \\comptime {
-        \\    @setGlobalSection(foo, ".text2");
-        \\}
-    ,
-        ".tmp_source.zig:3:5: error: cannot set section of external function 'foo'",
-        ".tmp_source.zig:1:8: note: declared here");
-
     cases.add("returning address of local variable - simple",
-        \\export fn foo() -> &i32 {
+        \\extern fn foo() -> &i32 {
         \\    var a: i32 = undefined;
         \\    return &a;
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:3:13: error: function returns address of local variable");
 
     cases.add("returning address of local variable - phi",
-        \\export fn foo(c: bool) -> &i32 {
+        \\extern fn foo(c: bool) -> &i32 {
         \\    var a: i32 = undefined;
         \\    var b: i32 = undefined;
         \\    return if (c) &a else &b;
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:4:12: error: function returns address of local variable");
 
@@ -1671,55 +1836,61 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:5:9: note: previous definition is here");
 
     cases.add("while expected bool, got nullable",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (bar()) {}
         \\}
         \\fn bar() -> ?i32 { 1 }
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:15: error: expected type 'bool', found '?i32'");
 
     cases.add("while expected bool, got error union",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (bar()) {}
         \\}
         \\fn bar() -> %i32 { 1 }
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:15: error: expected type 'bool', found '%i32'");
 
     cases.add("while expected nullable, got bool",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (bar()) |x| {}
         \\}
         \\fn bar() -> bool { true }
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:15: error: expected nullable type, found 'bool'");
 
     cases.add("while expected nullable, got error union",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (bar()) |x| {}
         \\}
         \\fn bar() -> %i32 { 1 }
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:15: error: expected nullable type, found '%i32'");
 
     cases.add("while expected error union, got bool",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (bar()) |x| {} else |err| {}
         \\}
         \\fn bar() -> bool { true }
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:15: error: expected error union type, found 'bool'");
 
     cases.add("while expected error union, got nullable",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (bar()) |x| {} else |err| {}
         \\}
         \\fn bar() -> ?i32 { 1 }
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:15: error: expected error union type, found '?i32'");
 
     cases.add("inline fn calls itself indirectly",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    bar();
         \\}
         \\inline fn bar() {
@@ -1731,29 +1902,33 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    quux();
         \\}
         \\extern fn quux();
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:4:8: error: unable to inline function");
 
     cases.add("save reference to inline function",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    quux(@ptrToInt(bar));
         \\}
         \\inline fn bar() { }
         \\extern fn quux(usize);
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:4:8: error: unable to inline function");
 
     cases.add("signed integer division",
-        \\export fn foo(a: i32, b: i32) -> i32 {
+        \\extern fn foo(a: i32, b: i32) -> i32 {
         \\    a / b
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:7: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact");
 
     cases.add("signed integer remainder division",
-        \\export fn foo(a: i32, b: i32) -> i32 {
+        \\extern fn foo(a: i32, b: i32) -> i32 {
         \\    a % b
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:7: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod");
 
@@ -1792,59 +1967,65 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:3:20: error: cast from 'u16' to 'u8' truncates bits");
 
     cases.add("@setDebugSafety twice for same scope",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    @setDebugSafety(this, false);
         \\    @setDebugSafety(this, false);
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:3:5: error: debug safety set twice for same scope",
         ".tmp_source.zig:2:5: note: first set here");
 
     cases.add("@setFloatMode twice for same scope",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    @setFloatMode(this, @import("builtin").FloatMode.Optimized);
         \\    @setFloatMode(this, @import("builtin").FloatMode.Optimized);
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:3:5: error: float mode set twice for same scope",
         ".tmp_source.zig:2:5: note: first set here");
 
     cases.add("array access of type",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    var b: u8[40] = undefined;
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:2:14: error: array access of non-array type 'type'");
 
     cases.add("cannot break out of defer expression",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (true) {
         \\        defer {
         \\            break;
         \\        }
         \\    }
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:4:13: error: cannot break out of defer expression");
 
     cases.add("cannot continue out of defer expression",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    while (true) {
         \\        defer {
         \\            continue;
         \\        }
         \\    }
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:4:13: error: cannot continue out of defer expression");
 
     cases.add("cannot goto out of defer expression",
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    defer {
         \\        goto label;
         \\    };
         \\label:
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:3:9: error: cannot goto out of defer expression");
 
@@ -1878,9 +2059,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const bar = baz + foo;
         \\const baz = 1;
         \\
-        \\export fn entry() -> i32 {
+        \\extern fn entry() -> i32 {
         \\    return bar;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:13: error: aoeu",
         ".tmp_source.zig:3:19: note: referenced here",
@@ -1893,9 +2075,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\
         \\var foo: Foo = undefined;
         \\
-        \\export fn entry() -> usize {
+        \\extern fn entry() -> usize {
         \\    return @sizeOf(@typeOf(foo.x));
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:13: error: struct 'Foo' contains itself");
 
@@ -1914,16 +2097,18 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:2:15: error: float literal out of range of any type");
 
     cases.add("explicit cast float literal to integer when there is a fraction component",
-        \\export fn entry() -> i32 {
+        \\extern fn entry() -> i32 {
         \\    i32(12.34)
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:9: error: fractional component prevents float value 12.340000 from being casted to type 'i32'");
 
     cases.add("non pointer given to @ptrToInt",
-        \\export fn entry(x: i32) -> usize {
+        \\extern fn entry(x: i32) -> usize {
         \\    @ptrToInt(x)
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:15: error: expected pointer, found 'i32'");
 
@@ -1942,24 +2127,27 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:2:15: error: exact shift shifted out 1 bits");
 
     cases.add("shifting without int type or comptime known",
-        \\export fn entry(x: u8) -> u8 {
+        \\extern fn entry(x: u8) -> u8 {
         \\    return 0x11 << x;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:17: error: LHS of shift must be an integer type, or RHS must be compile-time known");
 
     cases.add("shifting RHS is log2 of LHS int bit width",
-        \\export fn entry(x: u8, y: u8) -> u8 {
+        \\extern fn entry(x: u8, y: u8) -> u8 {
         \\    return x << y;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:17: error: expected type 'u3', found 'u8'");
 
     cases.add("globally shadowing a primitive type",
         \\const u16 = @intType(false, 8);
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const a: u16 = 300;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:1: error: declaration shadows type 'u16'");
 
@@ -1969,7 +2157,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    b: u32,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var foo = Foo { .a = 1, .b = 10 };
         \\    bar(&foo.b);
         \\}
@@ -1977,6 +2165,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn bar(x: &u32) {
         \\    *x += 1;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:8:13: error: expected type '&u32', found '&align(1) u32'");
 
@@ -1986,7 +2175,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    b: u32,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var foo = Foo { .a = 1, .b = 10 };
         \\    foo.b += 1;
         \\    bar((&foo.b)[0..1]);
@@ -1995,55 +2184,61 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn bar(x: []u32) {
         \\    x[0] += 1;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:9:17: error: expected type '[]u32', found '[]align(1) u32'");
 
     cases.add("increase pointer alignment in @ptrCast",
-        \\export fn entry() -> u32 {
+        \\extern fn entry() -> u32 {
         \\    var bytes: [4]u8 = []u8{0x01, 0x02, 0x03, 0x04};
         \\    const ptr = @ptrCast(&u32, &bytes[0]);
         \\    return *ptr;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:3:17: error: cast increases pointer alignment",
         ".tmp_source.zig:3:38: note: '&u8' has alignment 1",
         ".tmp_source.zig:3:27: note: '&u32' has alignment 4");
 
     cases.add("increase pointer alignment in slice resize",
-        \\export fn entry() -> u32 {
+        \\extern fn entry() -> u32 {
         \\    var bytes = []u8{0x01, 0x02, 0x03, 0x04};
         \\    return ([]u32)(bytes[0..])[0];
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:3:19: error: cast increases pointer alignment",
         ".tmp_source.zig:3:19: note: '[]u8' has alignment 1",
         ".tmp_source.zig:3:19: note: '[]u32' has alignment 4");
 
     cases.add("@alignCast expects pointer or slice",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    @alignCast(4, u32(3))
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:22: error: expected pointer or slice, found 'u32'");
 
     cases.add("passing an under-aligned function pointer",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
         \\}
         \\fn testImplicitlyDecreaseFnAlign(ptr: fn () align(8) -> i32, answer: i32) {
         \\    if (ptr() != answer) unreachable;
         \\}
         \\fn alignedSmall() align(4) -> i32 { 1234 }
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:35: error: expected type 'fn() align(8) -> i32', found 'fn() align(4) -> i32'");
 
     cases.add("passing a not-aligned-enough pointer to cmpxchg",
         \\const AtomicOrder = @import("builtin").AtomicOrder;
-        \\export fn entry() -> bool {
+        \\extern fn entry() -> bool {
         \\    var x: i32 align(1) = 1234;
         \\    while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
         \\    return x == 5678;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:4:23: error: expected pointer alignment of at least 4, found 1");
 
@@ -2069,17 +2264,18 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
     cases.add("wrong pointer implicitly casted to pointer to @OpaqueType()",
         \\const Derp = @OpaqueType();
         \\extern fn bar(d: &Derp);
-        \\export fn foo() {
+        \\extern fn foo() {
         \\    const x = u8(1);
         \\    bar(@ptrCast(&c_void, &x));
         \\}
+        \\comptime {@export("foo", foo);}
     ,
         ".tmp_source.zig:5:9: error: expected type '&Derp', found '&c_void'");
 
     cases.add("non-const variables of things that require const variables",
         \\const Opaque = @OpaqueType();
         \\
-        \\export fn entry(opaque: &Opaque) {
+        \\extern fn entry(opaque: &Opaque) {
         \\   var m2 = &2;
         \\   const y: u32 = *m2;
         \\
@@ -2099,6 +2295,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const Foo = struct {
         \\    fn bar(self: &const Foo) {}
         \\};
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:4:4: error: variable of type '&const (integer literal)' must be const or comptime",
         ".tmp_source.zig:7:4: error: variable of type '(undefined)' must be const or comptime",
@@ -2113,20 +2310,14 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:17:4: error: unreachable code");
 
     cases.add("wrong types given to atomic order args in cmpxchg",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchg(&x, 1234, 5678, u32(1234), u32(1234))) {}
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:3:41: error: expected type 'AtomicOrder', found 'u32'");
 
-    cases.add("wrong types given to setGlobalLinkage",
-        \\export fn entry() {
-        \\    @setGlobalLinkage(entry, u32(1234));
-        \\}
-    ,
-        ".tmp_source.zig:2:33: error: expected type 'GlobalLinkage', found 'u32'");
-
     cases.add("struct with invalid field",
         \\const std = @import("std");
         \\const Allocator = std.mem.Allocator;
@@ -2145,12 +2336,13 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    },
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const a = MdNode.Header {
         \\        .text = MdText.init(&std.debug.global_allocator),
         \\        .weight = HeaderWeight.H1,
         \\    };
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:14:17: error: use of undeclared identifier 'HeaderValue'");
 
@@ -2162,35 +2354,39 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:2:5: error: @setAlignStack outside function");
 
     cases.add("@setAlignStack in naked function",
-        \\export nakedcc fn entry() {
+        \\nakedcc fn entry() {
         \\    @setAlignStack(16);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:5: error: @setAlignStack in naked function");
 
     cases.add("@setAlignStack in inline function",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    foo();
         \\}
         \\inline fn foo() {
         \\    @setAlignStack(16);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:5:5: error: @setAlignStack in inline function");
 
     cases.add("@setAlignStack set twice",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    @setAlignStack(16);
         \\    @setAlignStack(16);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:3:5: error: alignstack set twice",
         ".tmp_source.zig:2:5: note: first set here");
 
     cases.add("@setAlignStack too big",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    @setAlignStack(511 + 1);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256");
 
@@ -2221,7 +2417,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    LinkLibC,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const tests = []TestCase {
         \\        Free("001"),
         \\        Free("002"),
@@ -2236,13 +2432,14 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        }
         \\    }
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:37:16: error: cannot store runtime value in compile time variable");
 
     cases.add("field access of opaque type",
         \\const MyType = @OpaqueType();
         \\
-        \\export fn entry() -> bool {
+        \\extern fn entry() -> bool {
         \\    var x: i32 = 1;
         \\    return bar(@ptrCast(&MyType, &x));
         \\}
@@ -2250,6 +2447,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\fn bar(x: &MyType) -> bool {
         \\    return x.blah;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:9:13: error: type '&MyType' does not support field access");
 
@@ -2353,10 +2551,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         ".tmp_source.zig:2:26: error: member index 1 out of bounds; 'Foo' has 1 members");
 
     cases.add("calling var args extern function, passing array instead of pointer",
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    foo("hello");
         \\}
         \\pub extern fn foo(format: &const u8, ...);
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:9: error: expected type '&const u8', found '[5]u8'");
 
@@ -2371,9 +2570,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    }
         \\}
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var allocator: ContextAllocator = undefined;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:4:25: error: aoeu",
         ".tmp_source.zig:1:36: note: called from here",
@@ -2388,9 +2588,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Five,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x = Small.One;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:20: error: 'u2' too small to hold all bits; must be at least 'u3'");
 
@@ -2401,9 +2602,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Three,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x = Small.One;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:20: error: expected integer, found 'f32'");
 
@@ -2415,9 +2617,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Four,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x: u2 = Small.Two;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:9:22: error: expected type 'u2', found 'Small'");
 
@@ -2429,9 +2632,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Four,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x = u3(Small.Two);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:9:15: error: enum to integer cast to 'u3' instead of its tag type, 'u2'");
 
@@ -2443,10 +2647,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Four,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var y = u3(3);
         \\    var x = Small(y);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:10:18: error: integer to enum cast from 'u3' instead of its tag type, 'u2'");
 
@@ -2458,9 +2663,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    Four,
         \\};
         \\
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var y = Small.Two;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:19: error: expected unsigned integer, found 'i2'");
 
@@ -2468,9 +2674,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const MultipleChoice = struct {
         \\    A: i32 = 20,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\        var x: MultipleChoice = undefined;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:14: error: enums, not structs, support field assignment");
 
@@ -2478,26 +2685,29 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const MultipleChoice = union {
         \\    A: i32 = 20,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x: MultipleChoice = undefined;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:14: error: non-enum union field assignment",
         ".tmp_source.zig:1:24: note: consider 'union(enum)' here");
 
     cases.add("enum with 0 fields",
         \\const Foo = enum {};
-        \\export fn entry() -> usize {
+        \\extern fn entry() -> usize {
         \\    return @sizeOf(Foo);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:13: error: enums must have 1 or more fields");
 
     cases.add("union with 0 fields",
         \\const Foo = union {};
-        \\export fn entry() -> usize {
+        \\extern fn entry() -> usize {
         \\    return @sizeOf(Foo);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:13: error: unions must have 1 or more fields");
 
@@ -2509,9 +2719,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    D = 1000,
         \\    E = 60,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x = MultipleChoice.C;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:9: error: enum tag value 60 already taken",
         ".tmp_source.zig:4:9: note: other occurrence here");
@@ -2526,9 +2737,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    A: i32,
         \\    B: f64,
         \\};
-        \\export fn entry() -> usize {
+        \\extern fn entry() -> usize {
         \\    return @sizeOf(Payload);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:17: error: enum field missing: 'C'",
         ".tmp_source.zig:4:5: note: declared here");
@@ -2537,9 +2749,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const Foo = union {
         \\    A: i32,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const x = @TagType(Foo);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:5:24: error: union 'Foo' has no tag",
         ".tmp_source.zig:1:13: note: consider 'union(enum)' here");
@@ -2548,9 +2761,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const Foo = union(enum(f32)) {
         \\    A: i32,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const x = @TagType(Foo);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:23: error: expected integer tag type, found 'f32'");
 
@@ -2558,9 +2772,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const Foo = union(u32) {
         \\    A: i32,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const x = @TagType(Foo);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:1:18: error: expected enum tag type, found 'u32'");
 
@@ -2572,9 +2787,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    D = 1000,
         \\    E = 60,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x = MultipleChoice { .C = {} };
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:9: error: enum tag value 60 already taken",
         ".tmp_source.zig:4:9: note: other occurrence here");
@@ -2591,9 +2807,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    C: bool,
         \\    D: bool,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var a = Payload {.A = 1234};
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:10:5: error: enum field not found: 'D'",
         ".tmp_source.zig:1:16: note: enum declared here");
@@ -2604,9 +2821,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    B,
         \\    C,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var b = Letter.B;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:8: error: structs and unions, not enums, support field types",
         ".tmp_source.zig:1:16: note: consider 'union(enum)' here");
@@ -2615,9 +2833,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const Letter = struct {
         \\    A,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var a = Letter { .A = {} };
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:5: error: struct field missing type");
 
@@ -2625,9 +2844,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\const Letter = extern union {
         \\    A,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var a = Letter { .A = {} };
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:2:5: error: union field missing type");
 
@@ -2642,9 +2862,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    B: f64,
         \\    C: bool,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var a = Payload { .A = { 1234 } };
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:29: error: extern union does not support enum tag type");
 
@@ -2659,9 +2880,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    B: f64,
         \\    C: bool,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var a = Payload { .A = { 1234 } };
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:29: error: packed union does not support enum tag type");
 
@@ -2671,7 +2893,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    B: f64,
         \\    C: bool,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    const a = Payload { .A = { 1234 } };
         \\    foo(a);
         \\}
@@ -2681,6 +2903,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\        else => unreachable,
         \\    }
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:11:13: error: switch on union which has no attached enum",
         ".tmp_source.zig:1:17: note: consider 'union(enum)' here");
@@ -2690,9 +2913,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    A = 10,
         \\    B = 11,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x = Foo(0);
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:6:16: error: enum 'Foo' has no tag matching integer value 0",
         ".tmp_source.zig:1:13: note: 'Foo' declared here");
@@ -2704,9 +2928,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    B,
         \\    C,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    var x: Value = Letter.A;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'",
         ".tmp_source.zig:3:5: note: field 'A' declared here");
@@ -2718,13 +2943,36 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
         \\    B,
         \\    C,
         \\};
-        \\export fn entry() {
+        \\extern fn entry() {
         \\    foo(Letter.A);
         \\}
         \\fn foo(l: Letter) {
         \\    var x: Value = l;
         \\}
+        \\comptime {@export("entry", entry);}
     ,
         ".tmp_source.zig:11:20: error: runtime cast to union 'Value' which has non-void fields",
         ".tmp_source.zig:3:5: note: field 'A' has type 'i32'");
+
+    cases.addCase({
+        const tc = cases.create("export collision",
+            \\const foo = @import("foo.zig");
+            \\
+            \\comptime {@export("bar", bar);}
+            \\extern fn bar() -> usize {
+            \\    return foo.baz;
+            \\}
+        ,
+            "foo.zig:2:11: error: exported symbol collision: 'bar'",
+            ".tmp_source.zig:3:11: note: other symbol is here");
+
+        tc.addSourceFile("foo.zig",
+            \\extern fn bar() {}
+            \\comptime {@export("bar", bar);}
+            \\pub const baz = 1234;
+        );
+
+        tc
+    });
+
 }