const tests = @import("tests.zig"); const builtin = @import("builtin"); pub fn addCases(cases: *tests.CompileErrorContext) void { cases.add( "import outside package path", \\comptime{ \\ _ = @import("../a.zig"); \\} , "tmp.zig:2:9: error: import of file outside package path: '../a.zig'", ); cases.add( "bogus compile var", \\const x = @import("builtin").bogus; \\export fn entry() usize { return @sizeOf(@typeOf(x)); } , "tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'", ); cases.add( "wrong panic signature, runtime function", \\test "" {} \\ \\pub fn panic() void {} \\ , "tmp.zig:3:5: error: expected type 'fn([]const u8, ?*builtin.StackTrace) noreturn', found 'fn() void'", ); cases.add( "wrong panic signature, generic function", \\pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn { \\ while (true) {} \\} , "tmp.zig:1:5: error: expected type 'fn([]const u8, ?*builtin.StackTrace) noreturn', found 'fn([]const u8,var)var'", "tmp.zig:1:5: note: only one of the functions is generic", ); cases.add( "direct struct loop", \\const A = struct { a : A, }; \\export fn entry() usize { return @sizeOf(A); } , "tmp.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 { return @sizeOf(A); } , "tmp.zig:1:11: error: struct 'A' contains itself", ); cases.add( "instantiating an undefined value for an invalid struct that contains itself", \\const Foo = struct { \\ x: Foo, \\}; \\ \\var foo: Foo = undefined; \\ \\export fn entry() usize { \\ return @sizeOf(@typeOf(foo.x)); \\} , "tmp.zig:1:13: error: struct 'Foo' contains itself", "tmp.zig:8:28: note: referenced here", ); cases.add( "@typeInfo causing depend on itself compile error", \\const start = struct { \\ fn crash() bug() { \\ return bug; \\ } \\}; \\fn bug() void { \\ _ = @typeInfo(start).Struct; \\} \\export fn entry() void { \\ var boom = start.crash(); \\} , "tmp.zig:7:9: error: dependency loop detected", "tmp.zig:2:19: note: called from here", "tmp.zig:10:21: note: referenced here", ); cases.add( "enum field value references enum", \\pub const Foo = extern enum { \\ A = Foo.B, \\ C = D, \\}; \\export fn entry() void { \\ var s: Foo = Foo.E; \\} , "tmp.zig:1:17: error: 'Foo' depends on itself", ); cases.add( "top level decl dependency loop", \\const a : @typeOf(b) = 0; \\const b : @typeOf(a) = 0; \\export fn entry() void { \\ const c = a + b; \\} , "tmp.zig:2:19: error: dependency loop detected", "tmp.zig:1:19: note: referenced here", "tmp.zig:4:15: note: referenced here", ); cases.addTest( "not an enum type", \\export fn entry() void { \\ var self: Error = undefined; \\ switch (self) { \\ InvalidToken => |x| return x.token, \\ ExpectedVarDeclOrFn => |x| return x.token, \\ } \\} \\const Error = union(enum) { \\ A: InvalidToken, \\ B: ExpectedVarDeclOrFn, \\}; \\const InvalidToken = struct {}; \\const ExpectedVarDeclOrFn = struct {}; , "tmp.zig:4:9: error: not an enum type", ); cases.addTest( "binary OR operator on error sets", \\pub const A = error.A; \\pub const AB = A | error.B; \\export fn entry() void { \\ var x: AB = undefined; \\} , "tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'", ); if (builtin.os == builtin.Os.linux) { cases.addTest( "implicit dependency on libc", \\extern "c" fn exit(u8) void; \\export fn entry() void { \\ exit(0); \\} , "tmp.zig:3:5: error: dependency on library c must be explicitly specified in the build command", ); cases.addTest( "libc headers note", \\const c = @cImport(@cInclude("stdio.h")); \\export fn entry() void { \\ _ = c.printf(c"hello, world!\n"); \\} , "tmp.zig:1:11: error: C import failed", "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc", ); } cases.addTest( "comptime vector overflow shows the index", \\comptime { \\ var a: @Vector(4, u8) = []u8{ 1, 2, 255, 4 }; \\ var b: @Vector(4, u8) = []u8{ 5, 6, 1, 8 }; \\ var x = a + b; \\} , "tmp.zig:4:15: error: operation caused overflow", "tmp.zig:4:15: note: when computing vector element at index 2", ); cases.addTest( "packed struct with fields of not allowed types", \\const A = packed struct { \\ x: anyerror, \\}; \\const B = packed struct { \\ x: [2]u24, \\}; \\const C = packed struct { \\ x: [1]anyerror, \\}; \\const D = packed struct { \\ x: [1]S, \\}; \\const E = packed struct { \\ x: [1]U, \\}; \\const F = packed struct { \\ x: ?anyerror, \\}; \\const G = packed struct { \\ x: Enum, \\}; \\export fn entry() void { \\ var a: A = undefined; \\ var b: B = undefined; \\ var r: C = undefined; \\ var d: D = undefined; \\ var e: E = undefined; \\ var f: F = undefined; \\ var g: G = undefined; \\} \\const S = struct { \\ x: i32, \\}; \\const U = struct { \\ A: i32, \\ B: u32, \\}; \\const Enum = enum { \\ A, \\ B, \\}; , "tmp.zig:2:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation", "tmp.zig:5:5: error: array of 'u24' not allowed in packed struct due to padding bits", "tmp.zig:8:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation", "tmp.zig:11:5: error: non-packed, non-extern struct 'S' not allowed in packed struct; no guaranteed in-memory representation", "tmp.zig:14:5: error: non-packed, non-extern struct 'U' not allowed in packed struct; no guaranteed in-memory representation", "tmp.zig:17:5: error: type '?anyerror' not allowed in packed struct; no guaranteed in-memory representation", "tmp.zig:20:5: error: type 'Enum' not allowed in packed struct; no guaranteed in-memory representation", "tmp.zig:38:14: note: enum declaration does not specify an integer tag type", ); cases.addCase(x: { var tc = cases.create( "deduplicate undeclared identifier", \\export fn a() void { \\ x += 1; \\} \\export fn b() void { \\ x += 1; \\} , "tmp.zig:2:5: error: use of undeclared identifier 'x'", ); tc.expect_exact = true; break :x tc; }); cases.addTest( "export generic function", \\export fn foo(num: var) i32 { \\ return 0; \\} , "tmp.zig:1:15: error: parameter of type 'var' not allowed in function with calling convention 'ccc'", ); cases.addTest( "C pointer to c_void", \\export fn a() void { \\ var x: *c_void = undefined; \\ var y: [*c]c_void = x; \\} , "tmp.zig:3:12: error: C pointers cannot point opaque types", ); cases.addTest( "directly embedding opaque type in struct and union", \\const O = @OpaqueType(); \\const Foo = struct { \\ o: O, \\}; \\const Bar = union { \\ One: i32, \\ Two: O, \\}; \\export fn a() void { \\ var foo: Foo = undefined; \\} \\export fn b() void { \\ var bar: Bar = undefined; \\} , "tmp.zig:3:8: error: opaque types have unknown size and therefore cannot be directly embedded in structs", "tmp.zig:7:10: error: opaque types have unknown size and therefore cannot be directly embedded in unions", ); cases.addTest( "implicit cast between C pointer and Zig pointer - bad const/align/child", \\export fn a() void { \\ var x: [*c]u8 = undefined; \\ var y: *align(4) u8 = x; \\} \\export fn b() void { \\ var x: [*c]const u8 = undefined; \\ var y: *u8 = x; \\} \\export fn c() void { \\ var x: [*c]u8 = undefined; \\ var y: *u32 = x; \\} \\export fn d() void { \\ var y: *align(1) u32 = undefined; \\ var x: [*c]u32 = y; \\} \\export fn e() void { \\ var y: *const u8 = undefined; \\ var x: [*c]u8 = y; \\} \\export fn f() void { \\ var y: *u8 = undefined; \\ var x: [*c]u32 = y; \\} , "tmp.zig:3:27: error: cast increases pointer alignment", "tmp.zig:7:18: error: cast discards const qualifier", "tmp.zig:11:19: error: expected type '*u32', found '[*c]u8'", "tmp.zig:11:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'", "tmp.zig:15:22: error: cast increases pointer alignment", "tmp.zig:19:21: error: cast discards const qualifier", "tmp.zig:23:22: error: expected type '[*c]u32', found '*u8'", ); cases.addTest( "implicit casting null c pointer to zig pointer", \\comptime { \\ var c_ptr: [*c]u8 = 0; \\ var zig_ptr: *u8 = c_ptr; \\} , "tmp.zig:3:24: error: null pointer casted to type '*u8'", ); cases.addTest( "implicit casting undefined c pointer to zig pointer", \\comptime { \\ var c_ptr: [*c]u8 = undefined; \\ var zig_ptr: *u8 = c_ptr; \\} , "tmp.zig:3:24: error: use of undefined value here causes undefined behavior", ); cases.addTest( "implicit casting C pointers which would mess up null semantics", \\export fn entry() void { \\ var slice: []const u8 = "aoeu"; \\ const opt_many_ptr: [*]const u8 = slice.ptr; \\ var ptr_opt_many_ptr = &opt_many_ptr; \\ var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr; \\ ptr_opt_many_ptr = c_ptr; \\} \\export fn entry2() void { \\ var buf: [4]u8 = "aoeu"; \\ var slice: []u8 = &buf; \\ var opt_many_ptr: [*]u8 = slice.ptr; \\ var ptr_opt_many_ptr = &opt_many_ptr; \\ var c_ptr: [*c][*c]const u8 = ptr_opt_many_ptr; \\} , "tmp.zig:6:24: error: expected type '*const [*]const u8', found '[*c]const [*c]const u8'", "tmp.zig:6:24: note: pointer type child '[*c]const u8' cannot cast into pointer type child '[*]const u8'", "tmp.zig:6:24: note: '[*c]const u8' could have null values which are illegal in type '[*]const u8'", "tmp.zig:13:35: error: expected type '[*c][*c]const u8', found '*[*]u8'", "tmp.zig:13:35: note: pointer type child '[*]u8' cannot cast into pointer type child '[*c]const u8'", "tmp.zig:13:35: note: mutable '[*c]const u8' allows illegal null values stored to type '[*]u8'", ); cases.addTest( "implicit casting too big integers to C pointers", \\export fn a() void { \\ var ptr: [*c]u8 = (1 << 64) + 1; \\} \\export fn b() void { \\ var x: @IntType(false, 65) = 0x1234; \\ var ptr: [*c]u8 = x; \\} , "tmp.zig:2:33: error: integer value 71615590737044764481 cannot be implicitly casted to type 'usize'", "tmp.zig:6:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'", ); cases.addTest( "C pointer pointing to non C ABI compatible type or has align attr", \\const Foo = struct {}; \\export fn a() void { \\ const T = [*c]Foo; \\} , "tmp.zig:3:15: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'", ); cases.addCase(x: { var tc = cases.create( "compile log statement warning deduplication in generic fn", \\export fn entry() void { \\ inner(1); \\ inner(2); \\} \\fn inner(comptime n: usize) void { \\ comptime var i = 0; \\ inline while (i < n) : (i += 1) { @compileLog("!@#$"); } \\} , "tmp.zig:7:39: error: found compile log statement", ); tc.expect_exact = true; break :x tc; }); cases.addTest( "assign to invalid dereference", \\export fn entry() void { \\ 'a'.* = 1; \\} , "tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'", ); cases.addTest( "take slice of invalid dereference", \\export fn entry() void { \\ const x = 'a'.*[0..]; \\} , "tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'", ); cases.addTest( "@truncate undefined value", \\export fn entry() void { \\ var z = @truncate(u8, u16(undefined)); \\} , "tmp.zig:2:30: error: use of undefined value here causes undefined behavior", ); cases.addTest( "return invalid type from test", \\test "example" { return 1; } , "tmp.zig:1:25: error: integer value 1 cannot be implicitly casted to type 'void'", ); cases.add( "threadlocal qualifier on const", \\threadlocal const x: i32 = 1234; \\export fn entry() i32 { \\ return x; \\} , "tmp.zig:1:13: error: threadlocal variable cannot be constant", ); cases.add( "threadlocal qualifier on local variable", \\export fn entry() void { \\ threadlocal var x: i32 = 1234; \\} , "tmp.zig:2:5: error: function-local variable 'x' cannot be threadlocal", ); cases.add( "@bitCast same size but bit count mismatch", \\export fn entry(byte: u8) void { \\ var oops = @bitCast(u7, byte); \\} , "tmp.zig:2:16: error: destination type 'u7' has 7 bits but source type 'u8' has 8 bits", ); cases.add( "attempted `&&`", \\export fn entry(a: bool, b: bool) i32 { \\ if (a && b) { \\ return 1234; \\ } \\ return 5678; \\} , "tmp.zig:2:12: error: `&&` is invalid. Note that `and` is boolean AND.", ); cases.add( "attempted `||` on boolean values", \\export fn entry(a: bool, b: bool) i32 { \\ if (a || b) { \\ return 1234; \\ } \\ return 5678; \\} , "tmp.zig:2:9: error: expected error set type, found 'bool'", "tmp.zig:2:11: note: `||` merges error sets; `or` performs boolean OR", ); cases.add( "compile log a pointer to an opaque value", \\export fn entry() void { \\ @compileLog(@ptrCast(*const c_void, &entry)); \\} , "tmp.zig:2:5: error: found compile log statement", ); cases.add( "duplicate boolean switch value", \\comptime { \\ const x = switch (true) { \\ true => false, \\ false => true, \\ true => false, \\ }; \\} \\comptime { \\ const x = switch (true) { \\ false => true, \\ true => false, \\ false => true, \\ }; \\} , "tmp.zig:5:9: error: duplicate switch value", "tmp.zig:12:9: error: duplicate switch value", ); cases.add( "missing boolean switch value", \\comptime { \\ const x = switch (true) { \\ true => false, \\ }; \\} \\comptime { \\ const x = switch (true) { \\ false => true, \\ }; \\} , "tmp.zig:2:15: error: switch must handle all possibilities", "tmp.zig:7:15: error: switch must handle all possibilities", ); cases.add( "reading past end of pointer casted array", \\comptime { \\ const array = "aoeu"; \\ const slice = array[1..]; \\ const int_ptr = @ptrCast(*const u24, slice.ptr); \\ const deref = int_ptr.*; \\} , "tmp.zig:5:26: error: attempt to read 4 bytes from [4]u8 at index 1 which is 3 bytes", ); cases.add( "error note for function parameter incompatibility", \\fn do_the_thing(func: fn (arg: i32) void) void {} \\fn bar(arg: bool) void {} \\export fn entry() void { \\ do_the_thing(bar); \\} , "tmp.zig:4:18: error: expected type 'fn(i32) void', found 'fn(bool) void", "tmp.zig:4:18: note: parameter 0: 'bool' cannot cast into 'i32'", ); cases.add( "cast negative value to unsigned integer", \\comptime { \\ const value: i32 = -1; \\ const unsigned = @intCast(u32, value); \\} \\export fn entry1() void { \\ const value: i32 = -1; \\ const unsigned: u32 = value; \\} , "tmp.zig:3:36: error: cannot cast negative value -1 to unsigned integer type 'u32'", "tmp.zig:7:27: error: cannot cast negative value -1 to unsigned integer type 'u32'", ); cases.add( "integer cast truncates bits", \\export fn entry1() void { \\ const spartan_count: u16 = 300; \\ const byte = @intCast(u8, spartan_count); \\} \\export fn entry2() void { \\ const spartan_count: u16 = 300; \\ const byte: u8 = spartan_count; \\} \\export fn entry3() void { \\ var spartan_count: u16 = 300; \\ var byte: u8 = spartan_count; \\} , "tmp.zig:3:31: error: integer value 300 cannot be implicitly casted to type 'u8'", "tmp.zig:7:22: error: integer value 300 cannot be implicitly casted to type 'u8'", "tmp.zig:11:20: error: expected type 'u8', found 'u16'", ); cases.add( "comptime implicit cast f64 to f32", \\export fn entry() void { \\ const x: f64 = 16777217; \\ const y: f32 = x; \\} , "tmp.zig:3:20: error: cast of value 16777217.000000 to type 'f32' loses information", ); cases.add( "implicit cast from f64 to f32", \\var x: f64 = 1.0; \\var y: f32 = x; \\ \\export fn entry() usize { return @sizeOf(@typeOf(y)); } , "tmp.zig:2:14: error: expected type 'f32', found 'f64'", ); cases.add( "exceeded maximum bit width of integer", \\export fn entry1() void { \\ const T = @IntType(false, 65536); \\} \\export fn entry2() void { \\ var x: i65536 = 1; \\} , "tmp.zig:2:31: error: integer value 65536 cannot be implicitly casted to type 'u16'", "tmp.zig:5:12: error: primitive integer type 'i65536' exceeds maximum bit width of 65535", ); cases.add( "compile error when evaluating return type of inferred error set", \\const Car = struct { \\ foo: *SymbolThatDoesNotExist, \\ pub fn init() !Car {} \\}; \\export fn entry() void { \\ const car = Car.init(); \\} , "tmp.zig:2:11: error: use of undeclared identifier 'SymbolThatDoesNotExist'", ); cases.add( "don't implicit cast double pointer to *c_void", \\export fn entry() void { \\ var a: u32 = 1; \\ var ptr: *c_void = &a; \\ var b: *u32 = @ptrCast(*u32, ptr); \\ var ptr2: *c_void = &b; \\} , "tmp.zig:5:26: error: expected type '*c_void', found '**u32'", ); cases.add( "runtime index into comptime type slice", \\const Struct = struct { \\ a: u32, \\}; \\fn getIndex() usize { \\ return 2; \\} \\export fn entry() void { \\ const index = getIndex(); \\ const field = @typeInfo(Struct).Struct.fields[index]; \\} , "tmp.zig:9:51: error: values of type 'builtin.StructField' must be comptime known, but index value is runtime known", ); cases.add( "compile log statement inside function which must be comptime evaluated", \\fn Foo(comptime T: type) type { \\ @compileLog(@typeName(T)); \\ return T; \\} \\export fn entry() void { \\ _ = Foo(i32); \\ _ = @typeName(Foo(i32)); \\} , "tmp.zig:2:5: error: found compile log statement", ); cases.add( "comptime slice of an undefined slice", \\comptime { \\ var a: []u8 = undefined; \\ var b = a[0..10]; \\} , "tmp.zig:3:14: error: slice of undefined", ); cases.add( "implicit cast const array to mutable slice", \\export fn entry() void { \\ const buffer: [1]u8 = []u8{8}; \\ const sliceA: []u8 = &buffer; \\} , "tmp.zig:3:27: error: expected type '[]u8', found '*const [1]u8'", ); cases.add( "deref slice and get len field", \\export fn entry() void { \\ var a: []u8 = undefined; \\ _ = a.*.len; \\} , "tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'", ); cases.add( "@ptrCast a 0 bit type to a non- 0 bit type", \\export fn entry() bool { \\ var x: u0 = 0; \\ const p = @ptrCast(?*u0, &x); \\ return p == null; \\} , "tmp.zig:3:15: error: '*u0' and '?*u0' do not have the same in-memory representation", "tmp.zig:3:31: note: '*u0' has no in-memory bits", "tmp.zig:3:24: note: '?*u0' has in-memory bits", ); cases.add( "comparing a non-optional pointer against null", \\export fn entry() void { \\ var x: i32 = 1; \\ _ = &x == null; \\} , "tmp.zig:3:12: error: comparison against null can only be done with optionals", ); cases.add( "non error sets used in merge error sets operator", \\export fn foo() void { \\ const Errors = u8 || u16; \\} \\export fn bar() void { \\ const Errors = error{} || u16; \\} , "tmp.zig:2:20: error: expected error set type, found type 'u8'", "tmp.zig:2:23: note: `||` merges error sets; `or` performs boolean OR", "tmp.zig:5:31: error: expected error set type, found type 'u16'", "tmp.zig:5:28: note: `||` merges error sets; `or` performs boolean OR", ); cases.add( "variable initialization compile error then referenced", \\fn Undeclared() type { \\ return T; \\} \\fn Gen() type { \\ const X = Undeclared(); \\ return struct { \\ x: X, \\ }; \\} \\export fn entry() void { \\ const S = Gen(); \\} , "tmp.zig:2:12: error: use of undeclared identifier 'T'", ); cases.add( "refer to the type of a generic function", \\export fn entry() void { \\ const Func = fn (type) void; \\ const f: Func = undefined; \\ f(i32); \\} , "tmp.zig:4:5: error: use of undefined value here causes undefined behavior", ); cases.add( "accessing runtime parameter from outer function", \\fn outer(y: u32) fn (u32) u32 { \\ const st = struct { \\ fn get(z: u32) u32 { \\ return z + y; \\ } \\ }; \\ return st.get; \\} \\export fn entry() void { \\ var func = outer(10); \\ var x = func(3); \\} , "tmp.zig:4:24: error: 'y' not accessible from inner function", "tmp.zig:3:28: note: crossed function definition here", "tmp.zig:1:10: note: declared here", ); cases.add( "non int passed to @intToFloat", \\export fn entry() void { \\ const x = @intToFloat(f32, 1.1); \\} , "tmp.zig:2:32: error: expected int type, found 'comptime_float'", ); cases.add( "non float passed to @floatToInt", \\export fn entry() void { \\ const x = @floatToInt(i32, i32(54)); \\} , "tmp.zig:2:35: error: expected float type, found 'i32'", ); cases.add( "out of range comptime_int passed to @floatToInt", \\export fn entry() void { \\ const x = @floatToInt(i8, 200); \\} , "tmp.zig:2:31: error: integer value 200 cannot be implicitly casted to type 'i8'", ); cases.add( "load too many bytes from comptime reinterpreted pointer", \\export fn entry() void { \\ const float: f32 = 5.99999999999994648725e-01; \\ const float_ptr = &float; \\ const int_ptr = @ptrCast(*const i64, float_ptr); \\ const int_val = int_ptr.*; \\} , "tmp.zig:5:28: error: attempt to read 8 bytes from pointer to f32 which is 4 bytes", ); cases.add( "invalid type used in array type", \\const Item = struct { \\ field: SomeNonexistentType, \\}; \\var items: [100]Item = undefined; \\export fn entry() void { \\ const a = items[0]; \\} , "tmp.zig:2:12: error: use of undeclared identifier 'SomeNonexistentType'", ); cases.add( "@noInlineCall on an inline function", \\inline fn foo() void {} \\ \\export fn entry() void { \\ @noInlineCall(foo); \\} , "tmp.zig:4:5: error: no-inline call of inline function", ); cases.add( "comptime continue inside runtime switch", \\export fn entry() void { \\ var p: i32 = undefined; \\ comptime var q = true; \\ inline while (q) { \\ switch (p) { \\ 11 => continue, \\ else => {}, \\ } \\ q = false; \\ } \\} , "tmp.zig:6:19: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "comptime continue inside runtime while error", \\export fn entry() void { \\ var p: anyerror!usize = undefined; \\ comptime var q = true; \\ outer: inline while (q) { \\ while (p) |_| { \\ continue :outer; \\ } else |_| {} \\ q = false; \\ } \\} , "tmp.zig:6:13: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "comptime continue inside runtime while optional", \\export fn entry() void { \\ var p: ?usize = undefined; \\ comptime var q = true; \\ outer: inline while (q) { \\ while (p) |_| continue :outer; \\ q = false; \\ } \\} , "tmp.zig:5:23: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "comptime continue inside runtime while bool", \\export fn entry() void { \\ var p: usize = undefined; \\ comptime var q = true; \\ outer: inline while (q) { \\ while (p == 11) continue :outer; \\ q = false; \\ } \\} , "tmp.zig:5:25: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "comptime continue inside runtime if error", \\export fn entry() void { \\ var p: anyerror!i32 = undefined; \\ comptime var q = true; \\ inline while (q) { \\ if (p) |_| continue else |_| {} \\ q = false; \\ } \\} , "tmp.zig:5:20: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "comptime continue inside runtime if optional", \\export fn entry() void { \\ var p: ?i32 = undefined; \\ comptime var q = true; \\ inline while (q) { \\ if (p) |_| continue; \\ q = false; \\ } \\} , "tmp.zig:5:20: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "comptime continue inside runtime if bool", \\export fn entry() void { \\ var p: usize = undefined; \\ comptime var q = true; \\ inline while (q) { \\ if (p == 11) continue; \\ q = false; \\ } \\} , "tmp.zig:5:22: error: comptime control flow inside runtime block", "tmp.zig:5:9: note: runtime block created here", ); cases.add( "switch with invalid expression parameter", \\export fn entry() void { \\ Test(i32); \\} \\fn Test(comptime T: type) void { \\ const x = switch (T) { \\ []u8 => |x| 123, \\ i32 => |x| 456, \\ else => unreachable, \\ }; \\} , "tmp.zig:7:17: error: switch on type 'type' provides no expression parameter", ); cases.add( "function protoype with no body", \\fn foo() void; \\export fn entry() void { \\ foo(); \\} , "tmp.zig:1:1: error: non-extern function has no body", ); cases.add( "@handle() called outside of function definition", \\var handle_undef: promise = undefined; \\var handle_dummy: promise = @handle(); \\export fn entry() bool { \\ return handle_undef == handle_dummy; \\} , "tmp.zig:2:29: error: @handle() called outside of function definition", ); cases.add( "@handle() in non-async function", \\export fn entry() bool { \\ var handle_undef: promise = undefined; \\ return handle_undef == @handle(); \\} , "tmp.zig:3:28: error: @handle() in non-async function", ); cases.add( "`_` is not a declarable symbol", \\export fn f1() usize { \\ var _: usize = 2; \\ return _; \\} , "tmp.zig:2:5: error: `_` is not a declarable symbol", "tmp.zig:3:12: error: use of undeclared identifier '_'", ); cases.add( "`_` should not be usable inside for", \\export fn returns() void { \\ for ([]void{}) |_, i| { \\ for ([]void{}) |_, j| { \\ return _; \\ } \\ } \\} , "tmp.zig:4:20: error: use of undeclared identifier '_'", ); cases.add( "`_` should not be usable inside while", \\export fn returns() void { \\ while (optionalReturn()) |_| { \\ while (optionalReturn()) |_| { \\ return _; \\ } \\ } \\} \\fn optionalReturn() ?u32 { \\ return 1; \\} , "tmp.zig:4:20: error: use of undeclared identifier '_'", ); cases.add( "`_` should not be usable inside while else", \\export fn returns() void { \\ while (optionalReturnError()) |_| { \\ while (optionalReturnError()) |_| { \\ return; \\ } else |_| { \\ if (_ == error.optionalReturnError) return; \\ } \\ } \\} \\fn optionalReturnError() !?u32 { \\ return error.optionalReturnError; \\} , "tmp.zig:6:17: error: use of undeclared identifier '_'", ); cases.add( "while loop body expression ignored", \\fn returns() usize { \\ return 2; \\} \\export fn f1() void { \\ while (true) returns(); \\} \\export fn f2() void { \\ var x: ?i32 = null; \\ while (x) |_| returns(); \\} \\export fn f3() void { \\ var x: anyerror!i32 = error.Bad; \\ while (x) |_| returns() else |_| unreachable; \\} , "tmp.zig:5:25: error: expression value is ignored", "tmp.zig:9:26: error: expression value is ignored", "tmp.zig:13:26: error: expression value is ignored", ); cases.add( "missing parameter name of generic function", \\fn dump(var) void {} \\export fn entry() void { \\ var a: u8 = 9; \\ dump(a); \\} , "tmp.zig:1:9: error: missing parameter name", ); cases.add( "non-inline for loop on a type that requires comptime", \\const Foo = struct { \\ name: []const u8, \\ T: type, \\}; \\export fn entry() void { \\ const xx: [2]Foo = undefined; \\ for (xx) |f| {} \\} , "tmp.zig:7:15: error: variable of type 'Foo' must be const or comptime", ); cases.add( "generic fn as parameter without comptime keyword", \\fn f(_: fn (var) void) void {} \\fn g(_: var) void {} \\export fn entry() void { \\ f(g); \\} , "tmp.zig:1:9: error: parameter of type 'fn(var)var' must be declared comptime", ); cases.add( "optional pointer to void in extern struct", \\const Foo = extern struct { \\ x: ?*const void, \\}; \\const Bar = extern struct { \\ foo: Foo, \\ y: i32, \\}; \\export fn entry(bar: *Bar) void {} , "tmp.zig:2:5: error: extern structs cannot contain fields of type '?*const void'", ); cases.add( "use of comptime-known undefined function value", \\const Cmd = struct { \\ exec: fn () void, \\}; \\export fn entry() void { \\ const command = Cmd{ .exec = undefined }; \\ command.exec(); \\} , "tmp.zig:6:12: error: use of undefined value here causes undefined behavior", ); cases.add( "use of comptime-known undefined function value", \\const Cmd = struct { \\ exec: fn () void, \\}; \\export fn entry() void { \\ const command = Cmd{ .exec = undefined }; \\ command.exec(); \\} , "tmp.zig:6:12: error: use of undefined value here causes undefined behavior", ); cases.add( "bad @alignCast at comptime", \\comptime { \\ const ptr = @intToPtr(*i32, 0x1); \\ const aligned = @alignCast(4, ptr); \\} , "tmp.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes", ); cases.add( "@ptrToInt on *void", \\export fn entry() bool { \\ return @ptrToInt(&{}) == @ptrToInt(&{}); \\} , "tmp.zig:2:23: error: pointer to size 0 type has no address", ); cases.add( "@popCount - non-integer", \\export fn entry(x: f32) u32 { \\ return @popCount(x); \\} , "tmp.zig:2:22: error: expected integer type, found 'f32'", ); cases.add( "@popCount - negative comptime_int", \\comptime { \\ _ = @popCount(-1); \\} , "tmp.zig:2:9: error: @popCount on negative comptime_int value -1", ); cases.addCase(x: { const tc = cases.create( "wrong same named struct", \\const a = @import("a.zig"); \\const b = @import("b.zig"); \\ \\export fn entry() void { \\ var a1: a.Foo = undefined; \\ bar(&a1); \\} \\ \\fn bar(x: *b.Foo) void {} , "tmp.zig:6:10: error: expected type '*b.Foo', found '*a.Foo'", "tmp.zig:6:10: note: pointer type child 'a.Foo' cannot cast into pointer type child 'b.Foo'", "a.zig:1:17: note: a.Foo declared here", "b.zig:1:17: note: b.Foo declared here", ); tc.addSourceFile("a.zig", \\pub const Foo = struct { \\ x: i32, \\}; ); tc.addSourceFile("b.zig", \\pub const Foo = struct { \\ z: f64, \\}; ); break :x tc; }); cases.add( "@floatToInt comptime safety", \\comptime { \\ _ = @floatToInt(i8, f32(-129.1)); \\} \\comptime { \\ _ = @floatToInt(u8, f32(-1.1)); \\} \\comptime { \\ _ = @floatToInt(u8, f32(256.1)); \\} , "tmp.zig:2:9: error: integer value '-129' cannot be stored in type 'i8'", "tmp.zig:5:9: error: integer value '-1' cannot be stored in type 'u8'", "tmp.zig:8:9: error: integer value '256' cannot be stored in type 'u8'", ); cases.add( "use c_void as return type of fn ptr", \\export fn entry() void { \\ const a: fn () c_void = undefined; \\} , "tmp.zig:2:20: error: return type cannot be opaque", ); cases.add( "use implicit casts to assign null to non-nullable pointer", \\export fn entry() void { \\ var x: i32 = 1234; \\ var p: *i32 = &x; \\ var pp: *?*i32 = &p; \\ pp.* = null; \\ var y = p.*; \\} , "tmp.zig:4:23: error: expected type '*?*i32', found '**i32'", ); cases.add( "attempted implicit cast from T to [*]const T", \\export fn entry() void { \\ const x: [*]const bool = true; \\} , "tmp.zig:2:30: error: expected type '[*]const bool', found 'bool'", ); cases.add( "dereference unknown length pointer", \\export fn entry(x: [*]i32) i32 { \\ return x.*; \\} , "tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'", ); cases.add( "field access of unknown length pointer", \\const Foo = extern struct { \\ a: i32, \\}; \\ \\export fn entry(foo: [*]Foo) void { \\ foo.a += 1; \\} , "tmp.zig:6:8: error: type '[*]Foo' does not support field access", ); cases.add( "unknown length pointer to opaque", \\export const T = [*]@OpaqueType(); , "tmp.zig:1:18: error: unknown-length pointer to opaque", ); cases.add( "error when evaluating return type", \\const Foo = struct { \\ map: i32(i32), \\ \\ fn init() Foo { \\ return undefined; \\ } \\}; \\export fn entry() void { \\ var rule_set = try Foo.init(); \\} , "tmp.zig:2:13: error: expected type 'i32', found 'type'", ); cases.add( "slicing single-item pointer", \\export fn entry(ptr: *i32) void { \\ const slice = ptr[0..2]; \\} , "tmp.zig:2:22: error: slice of single-item pointer", ); cases.add( "indexing single-item pointer", \\export fn entry(ptr: *i32) i32 { \\ return ptr[1]; \\} , "tmp.zig:2:15: error: index of single-item pointer", ); cases.add( "nested error set mismatch", \\const NextError = error{NextError}; \\const OtherError = error{OutOfMemory}; \\ \\export fn entry() void { \\ const a: ?NextError!i32 = foo(); \\} \\ \\fn foo() ?OtherError!i32 { \\ return null; \\} , "tmp.zig:5:34: error: expected type '?NextError!i32', found '?OtherError!i32'", "tmp.zig:5:34: note: optional type child 'OtherError!i32' cannot cast into optional type child 'NextError!i32'", "tmp.zig:5:34: note: error set 'OtherError' cannot cast into error set 'NextError'", "tmp.zig:2:26: note: 'error.OutOfMemory' not a member of destination error set", ); cases.add( "invalid deref on switch target", \\comptime { \\ var tile = Tile.Empty; \\ switch (tile.*) { \\ Tile.Empty => {}, \\ Tile.Filled => {}, \\ } \\} \\const Tile = enum { \\ Empty, \\ Filled, \\}; , "tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'", ); cases.add( "invalid field access in comptime", \\comptime { var x = doesnt_exist.whatever; } , "tmp.zig:1:20: error: use of undeclared identifier 'doesnt_exist'", ); cases.add( "suspend inside suspend block", \\const std = @import("std",); \\ \\export fn entry() void { \\ var buf: [500]u8 = undefined; \\ var a = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator; \\ const p = (async foo()) catch unreachable; \\ cancel p; \\} \\ \\async fn foo() void { \\ suspend { \\ suspend { \\ } \\ } \\} , "tmp.zig:12:9: error: cannot suspend inside suspend block", "tmp.zig:11:5: note: other suspend block here", ); cases.add( "assign inline fn to non-comptime var", \\export fn entry() void { \\ var a = b; \\} \\inline fn b() void { } , "tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var", "tmp.zig:4:1: note: declared here", ); cases.add( "wrong type passed to @panic", \\export fn entry() void { \\ var e = error.Foo; \\ @panic(e); \\} , "tmp.zig:3:12: error: expected type '[]const u8', found 'error{Foo}'", ); cases.add( "@tagName used on union with no associated enum tag", \\const FloatInt = extern union { \\ Float: f32, \\ Int: i32, \\}; \\export fn entry() void { \\ var fi = FloatInt{.Float = 123.45}; \\ var tagName = @tagName(fi); \\} , "tmp.zig:7:19: error: union has no associated enum", "tmp.zig:1:18: note: declared here", ); cases.add( "returning error from void async function", \\const std = @import("std",); \\export fn entry() void { \\ const p = async amain() catch unreachable; \\} \\async fn amain() void { \\ return error.ShouldBeCompileError; \\} , "tmp.zig:6:17: error: expected type 'void', found 'error{ShouldBeCompileError}'", ); cases.add( "var not allowed in structs", \\export fn entry() void { \\ var s = (struct{v: var}){.v=i32(10)}; \\} , "tmp.zig:2:23: error: invalid token: 'var'", ); cases.add( "@ptrCast discards const qualifier", \\export fn entry() void { \\ const x: i32 = 1234; \\ const y = @ptrCast(*i32, &x); \\} , "tmp.zig:3:15: error: cast discards const qualifier", ); cases.add( "comptime slice of undefined pointer non-zero len", \\export fn entry() void { \\ const slice = ([*]i32)(undefined)[0..1]; \\} , "tmp.zig:2:38: error: non-zero length slice of undefined pointer", ); cases.add( "type checking function pointers", \\fn a(b: fn (*const u8) void) void { \\ b('a'); \\} \\fn c(d: u8) void { \\ @import("std").debug.warn("{c}\n", d); \\} \\export fn entry() void { \\ a(c); \\} , "tmp.zig:8:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'", ); cases.add( "no else prong on switch on global error set", \\export fn entry() void { \\ foo(error.A); \\} \\fn foo(a: anyerror) void { \\ switch (a) { \\ error.A => {}, \\ } \\} , "tmp.zig:5:5: error: else prong required when switching on type 'anyerror'", ); cases.add( "inferred error set with no returned error", \\export fn entry() void { \\ foo() catch unreachable; \\} \\fn foo() !void { \\} , "tmp.zig:4:11: error: function with inferred error set must return at least one possible error", ); cases.add( "error not handled in switch", \\export fn entry() void { \\ foo(452) catch |err| switch (err) { \\ error.Foo => {}, \\ }; \\} \\fn foo(x: i32) !void { \\ switch (x) { \\ 0 ... 10 => return error.Foo, \\ 11 ... 20 => return error.Bar, \\ 21 ... 30 => return error.Baz, \\ else => {}, \\ } \\} , "tmp.zig:2:26: error: error.Baz not handled in switch", "tmp.zig:2:26: error: error.Bar not handled in switch", ); cases.add( "duplicate error in switch", \\export fn entry() void { \\ foo(452) catch |err| switch (err) { \\ error.Foo => {}, \\ error.Bar => {}, \\ error.Foo => {}, \\ else => {}, \\ }; \\} \\fn foo(x: i32) !void { \\ switch (x) { \\ 0 ... 10 => return error.Foo, \\ 11 ... 20 => return error.Bar, \\ else => {}, \\ } \\} , "tmp.zig:5:14: error: duplicate switch value: '@typeOf(foo).ReturnType.ErrorSet.Foo'", "tmp.zig:3:14: note: other value is here", ); cases.add("invalid cast from integral type to enum", \\const E = enum(usize) { One, Two }; \\ \\export fn entry() void { \\ foo(1); \\} \\ \\fn foo(x: usize) void { \\ switch (x) { \\ E.One => {}, \\ } \\} , "tmp.zig:9:10: error: expected type 'usize', found 'E'"); cases.add( "range operator in switch used on error set", \\export fn entry() void { \\ try foo(452) catch |err| switch (err) { \\ error.A ... error.B => {}, \\ else => {}, \\ }; \\} \\fn foo(x: i32) !void { \\ switch (x) { \\ 0 ... 10 => return error.Foo, \\ 11 ... 20 => return error.Bar, \\ else => {}, \\ } \\} , "tmp.zig:3:17: error: operator not allowed for errors", ); cases.add( "inferring error set of function pointer", \\comptime { \\ const z: ?fn()!void = null; \\} , "tmp.zig:2:15: error: inferring error set of return type valid only for function definitions", ); cases.add( "access non-existent member of error set", \\const Foo = error{A}; \\comptime { \\ const z = Foo.Bar; \\} , "tmp.zig:3:18: error: no error named 'Bar' in 'Foo'", ); cases.add( "error union operator with non error set LHS", \\comptime { \\ const z = i32!i32; \\} , "tmp.zig:2:15: error: expected error set type, found type 'i32'", ); cases.add( "error equality but sets have no common members", \\const Set1 = error{A, C}; \\const Set2 = error{B, D}; \\export fn entry() void { \\ foo(Set1.A); \\} \\fn foo(x: Set1) void { \\ if (x == Set2.B) { \\ \\ } \\} , "tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors", ); cases.add( "only equality binary operator allowed for error sets", \\comptime { \\ const z = error.A > error.B; \\} , "tmp.zig:2:23: error: operator not allowed for errors", ); cases.add( "explicit error set cast known at comptime violates error sets", \\const Set1 = error {A, B}; \\const Set2 = error {A, C}; \\comptime { \\ var x = Set1.B; \\ var y = @errSetCast(Set2, x); \\} , "tmp.zig:5:13: error: error.B not a member of error set 'Set2'", ); cases.add( "cast error union of global error set to error union of smaller error set", \\const SmallErrorSet = error{A}; \\export fn entry() void { \\ var x: SmallErrorSet!i32 = foo(); \\} \\fn foo() anyerror!i32 { \\ return error.B; \\} , "tmp.zig:3:35: error: expected type 'SmallErrorSet!i32', found 'anyerror!i32'", "tmp.zig:3:35: note: error set 'anyerror' cannot cast into error set 'SmallErrorSet'", "tmp.zig:3:35: note: cannot cast global error set into smaller set", ); cases.add( "cast global error set to error set", \\const SmallErrorSet = error{A}; \\export fn entry() void { \\ var x: SmallErrorSet = foo(); \\} \\fn foo() anyerror { \\ return error.B; \\} , "tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'", "tmp.zig:3:31: note: cannot cast global error set into smaller set", ); cases.add( "recursive inferred error set", \\export fn entry() void { \\ foo() catch unreachable; \\} \\fn foo() !void { \\ try foo(); \\} , "tmp.zig:5:5: error: cannot resolve inferred error set '@typeOf(foo).ReturnType.ErrorSet': function 'foo' not fully analyzed yet", ); cases.add( "implicit cast of error set not a subset", \\const Set1 = error{A, B}; \\const Set2 = error{A, C}; \\export fn entry() void { \\ foo(Set1.B); \\} \\fn foo(set1: Set1) void { \\ var x: Set2 = set1; \\} , "tmp.zig:7:19: error: expected type 'Set2', found 'Set1'", "tmp.zig:1:23: note: 'error.B' not a member of destination error set", ); cases.add( "int to err global invalid number", \\const Set1 = error{ \\ A, \\ B, \\}; \\comptime { \\ var x: u16 = 3; \\ var y = @intToError(x); \\} , "tmp.zig:7:13: error: integer value 3 represents no error", ); cases.add( "int to err non global invalid number", \\const Set1 = error{ \\ A, \\ B, \\}; \\const Set2 = error{ \\ A, \\ C, \\}; \\comptime { \\ var x = @errorToInt(Set1.B); \\ var y = @errSetCast(Set2, @intToError(x)); \\} , "tmp.zig:11:13: error: error.B not a member of error set 'Set2'", ); cases.add( "@memberCount of error", \\comptime { \\ _ = @memberCount(anyerror); \\} , "tmp.zig:2:9: error: global error set member count not available at comptime", ); cases.add( "duplicate error value in error set", \\const Foo = error { \\ Bar, \\ Bar, \\}; \\export fn entry() void { \\ const a: Foo = undefined; \\} , "tmp.zig:3:5: error: duplicate error: 'Bar'", "tmp.zig:2:5: note: other error here", ); cases.add( "cast negative integer literal to usize", \\export fn entry() void { \\ const x = usize(-10); \\} , "tmp.zig:2:21: error: cannot cast negative value -10 to unsigned integer type 'usize'", ); cases.add( "use invalid number literal as array index", \\var v = 25; \\export fn entry() void { \\ var arr: [v]u8 = undefined; \\} , "tmp.zig:1:1: error: unable to infer variable type", ); cases.add( "duplicate struct field", \\const Foo = struct { \\ Bar: i32, \\ Bar: usize, \\}; \\export fn entry() void { \\ const a: Foo = undefined; \\} , "tmp.zig:3:5: error: duplicate struct field: 'Bar'", "tmp.zig:2:5: note: other field here", ); cases.add( "duplicate union field", \\const Foo = union { \\ Bar: i32, \\ Bar: usize, \\}; \\export fn entry() void { \\ const a: Foo = undefined; \\} , "tmp.zig:3:5: error: duplicate union field: 'Bar'", "tmp.zig:2:5: note: other field here", ); cases.add( "duplicate enum field", \\const Foo = enum { \\ Bar, \\ Bar, \\}; \\ \\export fn entry() void { \\ const a: Foo = undefined; \\} , "tmp.zig:3:5: error: duplicate enum field: 'Bar'", "tmp.zig:2:5: note: other field here", ); cases.add( "calling function with naked calling convention", \\export fn entry() void { \\ foo(); \\} \\nakedcc fn foo() void { } , "tmp.zig:2:5: error: unable to call function with naked calling convention", "tmp.zig:4:1: note: declared here", ); cases.add( "function with invalid return type", \\export fn foo() boid {} , "tmp.zig:1:17: error: use of undeclared identifier 'boid'", ); cases.add( "function with non-extern non-packed enum parameter", \\const Foo = enum { A, B, C }; \\export fn entry(foo: Foo) void { } , "tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'", ); cases.add( "function with non-extern non-packed struct parameter", \\const Foo = struct { \\ A: i32, \\ B: f32, \\ C: bool, \\}; \\export fn entry(foo: Foo) void { } , "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'", ); cases.add( "function with non-extern non-packed union parameter", \\const Foo = union { \\ A: i32, \\ B: f32, \\ C: bool, \\}; \\export fn entry(foo: Foo) void { } , "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'", ); cases.add( "switch on enum with 1 field with no prongs", \\const Foo = enum { M }; \\ \\export fn entry() void { \\ var f = Foo.M; \\ switch (f) {} \\} , "tmp.zig:5:5: error: enumeration value 'Foo.M' not handled in switch", ); cases.add( "shift by negative comptime integer", \\comptime { \\ var a = 1 >> -1; \\} , "tmp.zig:2:18: error: shift by negative value -1", ); cases.add( "@panic called at compile time", \\export fn entry() void { \\ comptime { \\ @panic("aoeu",); \\ } \\} , "tmp.zig:3:9: error: encountered @panic at compile-time", ); cases.add( "wrong return type for main", \\pub fn main() f32 { } , "error: expected return type of main to be 'u8', 'noreturn', 'void', or '!void'", ); cases.add( "double ?? on main return value", \\pub fn main() ??void { \\} , "error: expected return type of main to be 'u8', 'noreturn', 'void', or '!void'", ); cases.add( "bad identifier in function with struct defined inside function which references local const", \\export fn entry() void { \\ const BlockKind = u32; \\ \\ const Block = struct { \\ kind: BlockKind, \\ }; \\ \\ bogus; \\} , "tmp.zig:8:5: error: use of undeclared identifier 'bogus'", ); cases.add( "labeled break not found", \\export fn entry() void { \\ blah: while (true) { \\ while (true) { \\ break :outer; \\ } \\ } \\} , "tmp.zig:4:13: error: label not found: 'outer'", ); cases.add( "labeled continue not found", \\export fn entry() void { \\ var i: usize = 0; \\ blah: while (i < 10) : (i += 1) { \\ while (true) { \\ continue :outer; \\ } \\ } \\} , "tmp.zig:5:13: error: labeled loop not found: 'outer'", ); cases.add( "attempt to use 0 bit type in extern fn", \\extern fn foo(ptr: extern fn(*void) void) void; \\ \\export fn entry() void { \\ foo(bar); \\} \\ \\extern fn bar(x: *void) void { } , "tmp.zig:1:30: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'ccc'", "tmp.zig:7:18: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'ccc'", ); cases.add( "implicit semicolon - block statement", \\export fn entry() void { \\ {} \\ var good = {}; \\ ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - block expr", \\export fn entry() void { \\ _ = {}; \\ var good = {}; \\ _ = {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - comptime statement", \\export fn entry() void { \\ comptime {} \\ var good = {}; \\ comptime ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - comptime expression", \\export fn entry() void { \\ _ = comptime {}; \\ var good = {}; \\ _ = comptime {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - defer", \\export fn entry() void { \\ defer {} \\ var good = {}; \\ defer ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if statement", \\export fn entry() void { \\ if(true) {} \\ var good = {}; \\ if(true) ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if expression", \\export fn entry() void { \\ _ = if(true) {}; \\ var good = {}; \\ _ = if(true) {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if-else statement", \\export fn entry() void { \\ if(true) {} else {} \\ var good = {}; \\ if(true) ({}) else ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if-else expression", \\export fn entry() void { \\ _ = if(true) {} else {}; \\ var good = {}; \\ _ = if(true) {} else {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if-else-if statement", \\export fn entry() void { \\ if(true) {} else if(true) {} \\ var good = {}; \\ if(true) ({}) else if(true) ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if-else-if expression", \\export fn entry() void { \\ _ = if(true) {} else if(true) {}; \\ var good = {}; \\ _ = if(true) {} else if(true) {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if-else-if-else statement", \\export fn entry() void { \\ if(true) {} else if(true) {} else {} \\ var good = {}; \\ if(true) ({}) else if(true) ({}) else ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - if-else-if-else expression", \\export fn entry() void { \\ _ = if(true) {} else if(true) {} else {}; \\ var good = {}; \\ _ = if(true) {} else if(true) {} else {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - test statement", \\export fn entry() void { \\ if (foo()) |_| {} \\ var good = {}; \\ if (foo()) |_| ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - test expression", \\export fn entry() void { \\ _ = if (foo()) |_| {}; \\ var good = {}; \\ _ = if (foo()) |_| {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - while statement", \\export fn entry() void { \\ while(true) {} \\ var good = {}; \\ while(true) ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - while expression", \\export fn entry() void { \\ _ = while(true) {}; \\ var good = {}; \\ _ = while(true) {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - while-continue statement", \\export fn entry() void { \\ while(true):({}) {} \\ var good = {}; \\ while(true):({}) ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - while-continue expression", \\export fn entry() void { \\ _ = while(true):({}) {}; \\ var good = {}; \\ _ = while(true):({}) {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - for statement", \\export fn entry() void { \\ for(foo()) |_| {} \\ var good = {}; \\ for(foo()) |_| ({}) \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "implicit semicolon - for expression", \\export fn entry() void { \\ _ = for(foo()) |_| {}; \\ var good = {}; \\ _ = for(foo()) |_| {} \\ var bad = {}; \\} , "tmp.zig:5:5: error: expected token ';', found 'var'", ); cases.add( "multiple function definitions", \\fn a() void {} \\fn a() void {} \\export fn entry() void { a(); } , "tmp.zig:2:1: error: redefinition of 'a'", ); cases.add( "unreachable with return", \\fn a() noreturn {return;} \\export fn entry() void { a(); } , "tmp.zig:1:18: error: expected type 'noreturn', found 'void'", ); cases.add( "control reaches end of non-void function", \\fn a() i32 {} \\export fn entry() void { _ = a(); } , "tmp.zig:1:12: error: expected type 'i32', found 'void'", ); cases.add( "undefined function call", \\export fn a() void { \\ b(); \\} , "tmp.zig:2:5: error: use of undeclared identifier 'b'", ); cases.add( "wrong number of arguments", \\export fn a() void { \\ b(1); \\} \\fn b(a: i32, b: i32, c: i32) void { } , "tmp.zig:2:6: error: expected 3 arguments, found 1", ); cases.add( "invalid type", \\fn a() bogus {} \\export fn entry() void { _ = a(); } , "tmp.zig:1:8: error: use of undeclared identifier 'bogus'", ); cases.add( "pointer to noreturn", \\fn a() *noreturn {} \\export fn entry() void { _ = a(); } , "tmp.zig:1:8: error: pointer to noreturn not allowed", ); cases.add( "unreachable code", \\export fn a() void { \\ return; \\ b(); \\} \\ \\fn b() void {} , "tmp.zig:3:5: error: unreachable code", ); cases.add( "bad import", \\const bogus = @import("bogus-does-not-exist.zig",); \\export fn entry() void { bogus.bogo(); } , "tmp.zig:1:15: error: unable to find 'bogus-does-not-exist.zig'", ); cases.add( "undeclared identifier", \\export fn a() void { \\ return \\ b + \\ c; \\} , "tmp.zig:3:5: error: use of undeclared identifier 'b'", "tmp.zig:4:5: error: use of undeclared identifier 'c'", ); cases.add( "parameter redeclaration", \\fn f(a : i32, a : i32) void { \\} \\export fn entry() void { f(1, 2); } , "tmp.zig:1:15: error: redeclaration of variable 'a'", ); cases.add( "local variable redeclaration", \\export fn f() void { \\ const a : i32 = 0; \\ const a = 0; \\} , "tmp.zig:3:5: error: redeclaration of variable 'a'", ); cases.add( "local variable redeclares parameter", \\fn f(a : i32) void { \\ const a = 0; \\} \\export fn entry() void { f(1); } , "tmp.zig:2:5: error: redeclaration of variable 'a'", ); cases.add( "variable has wrong type", \\export fn f() i32 { \\ const a = c"a"; \\ return a; \\} , "tmp.zig:3:12: error: expected type 'i32', found '[*]const u8'", ); cases.add( "if condition is bool, not int", \\export fn f() void { \\ if (0) {} \\} , "tmp.zig:2:9: error: expected type 'bool', found 'comptime_int'", ); cases.add( "assign unreachable", \\export fn f() void { \\ const a = return; \\} , "tmp.zig:2:5: error: unreachable code", ); cases.add( "unreachable variable", \\export fn f() void { \\ const a: noreturn = {}; \\} , "tmp.zig:2:14: error: variable of type 'noreturn' not allowed", ); cases.add( "unreachable parameter", \\fn f(a: noreturn) void {} \\export fn entry() void { f(); } , "tmp.zig:1:9: error: parameter of type 'noreturn' not allowed", ); cases.add( "bad assignment target", \\export fn f() void { \\ 3 = 3; \\} , "tmp.zig:2:7: error: cannot assign to constant", ); cases.add( "assign to constant variable", \\export fn f() void { \\ const a = 3; \\ a = 4; \\} , "tmp.zig:3:7: error: cannot assign to constant", ); cases.add( "use of undeclared identifier", \\export fn f() void { \\ b = 3; \\} , "tmp.zig:2:5: error: use of undeclared identifier 'b'", ); cases.add( "const is a statement, not an expression", \\export fn f() void { \\ (const a = 0); \\} , "tmp.zig:2:6: error: invalid token: 'const'", ); cases.add( "array access of undeclared identifier", \\export fn f() void { \\ i[i] = i[i]; \\} , "tmp.zig:2:5: error: use of undeclared identifier 'i'", ); cases.add( "array access of non array", \\export fn f() void { \\ var bad : bool = undefined; \\ bad[bad] = bad[bad]; \\} , "tmp.zig:3:8: error: array access of non-array type 'bool'", "tmp.zig:3:19: error: array access of non-array type 'bool'", ); cases.add( "array access with non integer index", \\export fn f() void { \\ var array = "aoeu"; \\ var bad = false; \\ array[bad] = array[bad]; \\} , "tmp.zig:4:11: error: expected type 'usize', found 'bool'", "tmp.zig:4:24: error: expected type 'usize', found 'bool'", ); cases.add( "write to const global variable", \\const x : i32 = 99; \\fn f() void { \\ x = 1; \\} \\export fn entry() void { f(); } , "tmp.zig:3:7: error: cannot assign to constant", ); cases.add( "missing else clause", \\fn f(b: bool) void { \\ const x : i32 = if (b) h: { break :h 1; }; \\ const y = if (b) h: { break :h i32(1); }; \\} \\export fn entry() void { f(true); } , "tmp.zig:2:42: error: integer value 1 cannot be implicitly casted to type 'void'", "tmp.zig:3:15: error: incompatible types: 'i32' and 'void'", ); cases.add( "invalid struct field", \\const A = struct { x : i32, }; \\export fn f() void { \\ var a : A = undefined; \\ a.foo = 1; \\ const y = a.bar; \\} , "tmp.zig:4:6: error: no member named 'foo' in struct 'A'", "tmp.zig:5:16: error: no member named 'bar' in struct 'A'", ); cases.add( "redefinition of struct", \\const A = struct { x : i32, }; \\const A = struct { y : i32, }; , "tmp.zig:2:1: error: redefinition of 'A'", ); cases.add( "redefinition of enums", \\const A = enum {}; \\const A = enum {}; , "tmp.zig:2:1: error: redefinition of 'A'", ); cases.add( "redefinition of global variables", \\var a : i32 = 1; \\var a : i32 = 2; , "tmp.zig:2:1: error: redefinition of 'a'", "tmp.zig:1:1: note: previous definition is here", ); cases.add( "duplicate field in struct value expression", \\const A = struct { \\ x : i32, \\ y : i32, \\ z : i32, \\}; \\export fn f() void { \\ const a = A { \\ .z = 1, \\ .y = 2, \\ .x = 3, \\ .z = 4, \\ }; \\} , "tmp.zig:11:9: error: duplicate field", ); cases.add( "missing field in struct value expression", \\const A = struct { \\ x : i32, \\ y : i32, \\ z : i32, \\}; \\export fn f() void { \\ // we want the error on the '{' not the 'A' because \\ // the A could be a complicated expression \\ const a = A { \\ .z = 4, \\ .y = 2, \\ }; \\} , "tmp.zig:9:17: error: missing field: 'x'", ); cases.add( "invalid field in struct value expression", \\const A = struct { \\ x : i32, \\ y : i32, \\ z : i32, \\}; \\export fn f() void { \\ const a = A { \\ .z = 4, \\ .y = 2, \\ .foo = 42, \\ }; \\} , "tmp.zig:10:9: error: no member named 'foo' in struct 'A'", ); cases.add( "invalid break expression", \\export fn f() void { \\ break; \\} , "tmp.zig:2:5: error: break expression outside loop", ); cases.add( "invalid continue expression", \\export fn f() void { \\ continue; \\} , "tmp.zig:2:5: error: continue expression outside loop", ); cases.add( "invalid maybe type", \\export fn f() void { \\ if (true) |x| { } \\} , "tmp.zig:2:9: error: expected optional type, found 'bool'", ); cases.add( "cast unreachable", \\fn f() i32 { \\ return i32(return 1); \\} \\export fn entry() void { _ = f(); } , "tmp.zig:2:15: error: unreachable code", ); cases.add( "invalid builtin fn", \\fn f() @bogus(foo) { \\} \\export fn entry() void { _ = f(); } , "tmp.zig:1:8: error: invalid builtin function: 'bogus'", ); cases.add( "noalias on non pointer param", \\fn f(noalias x: i32) void {} \\export fn entry() void { f(1234); } , "tmp.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 { return @sizeOf(@typeOf(foo)); } , "tmp.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 { \\ return 1; \\} , "tmp.zig:1:1: error: variable of type 'type' must be constant", ); cases.add( "variables shadowing types", \\const Foo = struct {}; \\const Bar = struct {}; \\ \\fn f(Foo: i32) void { \\ var Bar : i32 = undefined; \\} \\ \\export fn entry() void { \\ f(1234); \\} , "tmp.zig:4:6: error: redefinition of 'Foo'", "tmp.zig:1:1: note: previous definition is here", "tmp.zig:5:5: error: redefinition of 'Bar'", "tmp.zig:2:1: note: previous definition is here", ); cases.add( "switch expression - missing enumeration prong", \\const Number = enum { \\ One, \\ Two, \\ Three, \\ Four, \\}; \\fn f(n: Number) i32 { \\ switch (n) { \\ Number.One => 1, \\ Number.Two => 2, \\ Number.Three => i32(3), \\ } \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:8:5: error: enumeration value 'Number.Four' not handled in switch", ); cases.add( "switch expression - duplicate enumeration prong", \\const Number = enum { \\ One, \\ Two, \\ Three, \\ Four, \\}; \\fn f(n: Number) i32 { \\ switch (n) { \\ Number.One => 1, \\ Number.Two => 2, \\ Number.Three => i32(3), \\ Number.Four => 4, \\ Number.Two => 2, \\ } \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:13:15: error: duplicate switch value", "tmp.zig:10:15: note: other value is here", ); cases.add( "switch expression - duplicate enumeration prong when else present", \\const Number = enum { \\ One, \\ Two, \\ Three, \\ Four, \\}; \\fn f(n: Number) i32 { \\ switch (n) { \\ Number.One => 1, \\ Number.Two => 2, \\ Number.Three => i32(3), \\ Number.Four => 4, \\ Number.Two => 2, \\ else => 10, \\ } \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:13:15: error: duplicate switch value", "tmp.zig:10:15: note: other value is here", ); cases.add( "switch expression - multiple else prongs", \\fn f(x: u32) void { \\ const value: bool = switch (x) { \\ 1234 => false, \\ else => true, \\ else => true, \\ }; \\} \\export fn entry() void { \\ f(1234); \\} , "tmp.zig:5:9: error: multiple else prongs in switch expression", ); cases.add( "switch expression - non exhaustive integer prongs", \\fn foo(x: u8) void { \\ switch (x) { \\ 0 => {}, \\ } \\} \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:2:5: error: switch must handle all possibilities", ); cases.add( "switch expression - duplicate or overlapping integer value", \\fn foo(x: u8) u8 { \\ return switch (x) { \\ 0 ... 100 => u8(0), \\ 101 ... 200 => 1, \\ 201, 203 ... 207 => 2, \\ 206 ... 255 => 3, \\ }; \\} \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:6:9: error: duplicate switch value", "tmp.zig:5:14: note: previous value is here", ); cases.add( "switch expression - switch on pointer type with no else", \\fn foo(x: *u8) void { \\ switch (x) { \\ &y => {}, \\ } \\} \\const y: u8 = 100; \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.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 { return x; } , "tmp.zig:2:11: error: unable to evaluate constant expression", ); cases.add( "array concatenation with wrong type", \\const src = "aoeu"; \\const derp = usize(1234); \\const a = derp ++ "foo"; \\ \\export fn entry() usize { return @sizeOf(@typeOf(a)); } , "tmp.zig:3:11: error: expected array or C string literal, found 'usize'", ); cases.add( "non compile time array concatenation", \\fn f() []u8 { \\ return s ++ "foo"; \\} \\var s: [10]u8 = undefined; \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:2:12: error: unable to evaluate constant expression", ); cases.add( "@cImport with bogus include", \\const c = @cImport(@cInclude("bogus.h")); \\export fn entry() usize { return @sizeOf(@typeOf(c.bogo)); } , "tmp.zig:1:11: error: C import failed", ".h:1:10: note: 'bogus.h' file not found", ); cases.add( "address of number literal", \\const x = 3; \\const y = &x; \\fn foo() *const i32 { return y; } \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:3:30: error: expected type '*const i32', found '*const comptime_int'", ); cases.add( "integer overflow error", \\const x : u8 = 300; \\export fn entry() usize { return @sizeOf(@typeOf(x)); } , "tmp.zig:1:16: error: integer value 300 cannot be implicitly casted to type 'u8'", ); cases.add( "invalid shift amount error", \\const x : u8 = 2; \\fn f() u16 { \\ return x << 8; \\} \\export fn entry() u16 { return f(); } , "tmp.zig:3:14: error: RHS of shift is too large for LHS type", "tmp.zig:3:17: note: value 8 cannot fit into type u3", ); cases.add( "incompatible number literals", \\const x = 2 == 2.0; \\export fn entry() usize { return @sizeOf(@typeOf(x)); } , "tmp.zig:1:11: error: integer value 2 cannot be implicitly casted to type 'comptime_float'", ); cases.add( "missing function call param", \\const Foo = struct { \\ a: i32, \\ b: i32, \\ \\ fn member_a(foo: *const Foo) i32 { \\ return foo.a; \\ } \\ fn member_b(foo: *const Foo) i32 { \\ return foo.b; \\ } \\}; \\ \\const member_fn_type = @typeOf(Foo.member_a); \\const members = []member_fn_type { \\ Foo.member_a, \\ Foo.member_b, \\}; \\ \\fn f(foo: *const Foo, index: usize) void { \\ const result = members[index](); \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:20:34: error: expected 1 arguments, found 0", ); cases.add( "missing function name and param name", \\fn () void {} \\fn f(i32) void {} \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:1:1: error: missing function name", "tmp.zig:2:6: error: missing parameter name", ); cases.add( "wrong function type", \\const fns = []fn() void { a, b, c }; \\fn a() i32 {return 0;} \\fn b() i32 {return 1;} \\fn c() i32 {return 2;} \\export fn entry() usize { return @sizeOf(@typeOf(fns)); } , "tmp.zig:1:27: error: expected type 'fn() void', found 'fn() i32'", ); cases.add( "extern function pointer mismatch", \\const fns = [](fn(i32)i32) { a, b, c }; \\pub fn a(x: i32) i32 {return x + 0;} \\pub fn b(x: i32) i32 {return x + 1;} \\export fn c(x: i32) i32 {return x + 2;} \\ \\export fn entry() usize { return @sizeOf(@typeOf(fns)); } , "tmp.zig:1:36: error: expected type 'fn(i32) i32', found 'extern fn(i32) i32'", ); cases.add( "colliding invalid top level functions", \\fn func() bogus {} \\fn func() bogus {} \\export fn entry() usize { return @sizeOf(@typeOf(func)); } , "tmp.zig:2:1: error: redefinition of 'func'", "tmp.zig:1:11: error: use of undeclared identifier 'bogus'", ); cases.add( "non constant expression in array size outside function", \\const Foo = struct { \\ y: [get()]u8, \\}; \\var global_var: usize = 1; \\fn get() usize { return global_var; } \\ \\export fn entry() usize { return @sizeOf(@typeOf(Foo)); } , "tmp.zig:5:25: error: unable to evaluate constant expression", "tmp.zig:2:12: note: called from here", "tmp.zig:2:8: note: called from here", ); cases.add( "addition with non numbers", \\const Foo = struct { \\ field: i32, \\}; \\const x = Foo {.field = 1} + Foo {.field = 2}; \\ \\export fn entry() usize { return @sizeOf(@typeOf(x)); } , "tmp.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'", ); cases.add( "division by zero", \\const lit_int_x = 1 / 0; \\const lit_float_x = 1.0 / 0.0; \\const int_x = u32(1) / u32(0); \\const float_x = f32(1.0) / f32(0.0); \\ \\export fn entry1() usize { return @sizeOf(@typeOf(lit_int_x)); } \\export fn entry2() usize { return @sizeOf(@typeOf(lit_float_x)); } \\export fn entry3() usize { return @sizeOf(@typeOf(int_x)); } \\export fn entry4() usize { return @sizeOf(@typeOf(float_x)); } , "tmp.zig:1:21: error: division by zero", "tmp.zig:2:25: error: division by zero", "tmp.zig:3:22: error: division by zero", "tmp.zig:4:26: error: division by zero", ); cases.add( "normal string with newline", \\const foo = "a \\b"; \\ \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:1:15: error: newline not allowed in string literal", ); cases.add( "invalid comparison for function pointers", \\fn foo() void {} \\const invalid = foo > foo; \\ \\export fn entry() usize { return @sizeOf(@typeOf(invalid)); } , "tmp.zig:2:21: error: operator not allowed for type 'fn() void'", ); cases.add( "generic function instance with non-constant expression", \\fn foo(comptime x: i32, y: i32) i32 { return x + y; } \\fn test1(a: i32, b: i32) i32 { \\ return foo(a, b); \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(test1)); } , "tmp.zig:3:16: error: unable to evaluate constant expression", ); cases.add( "assign null to non-optional pointer", \\const a: *u8 = null; \\ \\export fn entry() usize { return @sizeOf(@typeOf(a)); } , "tmp.zig:1:16: error: expected type '*u8', found '(null)'", ); cases.add( "indexing an array of size zero", \\const array = []u8{}; \\export fn foo() void { \\ const pointer = &array[0]; \\} , "tmp.zig:3:27: error: index 0 outside array of size 0", ); cases.add( "compile time division by zero", \\const y = foo(0); \\fn foo(x: u32) u32 { \\ return 1 / x; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(y)); } , "tmp.zig:3:14: error: division by zero", "tmp.zig:1:14: note: called from here", ); cases.add( "branch on undefined value", \\const x = if (undefined) true else false; \\ \\export fn entry() usize { return @sizeOf(@typeOf(x)); } , "tmp.zig:1:15: error: use of undefined value here causes undefined behavior", ); cases.add( "div on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a / a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "div assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a /= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "mod on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a % a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "mod assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a %= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "add on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a + a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "add assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a += a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "add wrap on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a +% a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "add wrap assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a +%= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "sub on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a - a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "sub assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a -= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "sub wrap on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a -% a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "sub wrap assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a -%= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "mult on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a * a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "mult assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a *= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "mult wrap on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a *% a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "mult wrap assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a *%= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "shift left on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a << 2; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "shift left assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a <<= 2; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "shift right on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a >> 2; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "shift left assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a >>= 2; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "bin and on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a & a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "bin and assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a &= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "bin or on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a | a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "bin or assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a |= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "bin xor on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a ^ a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "bin xor assign on undefined value", \\comptime { \\ var a: i64 = undefined; \\ a ^= a; \\} , "tmp.zig:3:5: error: use of undefined value here causes undefined behavior", ); cases.add( "equal on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a == a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "not equal on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a != a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "greater than on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a > a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "greater than equal on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a >= a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "less than on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a < a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "less than equal on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = a <= a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "and on undefined value", \\comptime { \\ var a: bool = undefined; \\ _ = a and a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "or on undefined value", \\comptime { \\ var a: bool = undefined; \\ _ = a or a; \\} , "tmp.zig:3:9: error: use of undefined value here causes undefined behavior", ); cases.add( "negate on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = -a; \\} , "tmp.zig:3:10: error: use of undefined value here causes undefined behavior", ); cases.add( "negate wrap on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = -%a; \\} , "tmp.zig:3:11: error: use of undefined value here causes undefined behavior", ); cases.add( "bin not on undefined value", \\comptime { \\ var a: i64 = undefined; \\ _ = ~a; \\} , "tmp.zig:3:10: error: use of undefined value here causes undefined behavior", ); cases.add( "bool not on undefined value", \\comptime { \\ var a: bool = undefined; \\ _ = !a; \\} , "tmp.zig:3:10: error: use of undefined value here causes undefined behavior", ); cases.add( "orelse on undefined value", \\comptime { \\ var a: ?bool = undefined; \\ _ = a orelse false; \\} , "tmp.zig:3:11: error: use of undefined value here causes undefined behavior", ); cases.add( "catch on undefined value", \\comptime { \\ var a: anyerror!bool = undefined; \\ _ = a catch |err| false; \\} , "tmp.zig:3:11: error: use of undefined value here causes undefined behavior", ); cases.add( "deref on undefined value", \\comptime { \\ var a: *u8 = undefined; \\ _ = a.*; \\} , "tmp.zig:3:9: error: attempt to dereference undefined value", ); cases.add( "endless loop in function evaluation", \\const seventh_fib_number = fibbonaci(7); \\fn fibbonaci(x: i32) i32 { \\ return fibbonaci(x - 1) + fibbonaci(x - 2); \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(seventh_fib_number)); } , "tmp.zig:3:21: error: evaluation exceeded 1000 backwards branches", "tmp.zig:3:21: note: called from here", ); cases.add( "@embedFile with bogus file", \\const resource = @embedFile("bogus.txt",); \\ \\export fn entry() usize { return @sizeOf(@typeOf(resource)); } , "tmp.zig:1:29: error: unable to find '", "bogus.txt'", ); cases.add( "non-const expression in struct literal outside function", \\const Foo = struct { \\ x: i32, \\}; \\const a = Foo {.x = get_it()}; \\extern fn get_it() i32; \\ \\export fn entry() usize { return @sizeOf(@typeOf(a)); } , "tmp.zig:4:21: error: unable to evaluate constant expression", ); cases.add( "non-const expression function call with struct return value outside function", \\const Foo = struct { \\ x: i32, \\}; \\const a = get_it(); \\fn get_it() Foo { \\ global_side_effect = true; \\ return Foo {.x = 13}; \\} \\var global_side_effect = false; \\ \\export fn entry() usize { return @sizeOf(@typeOf(a)); } , "tmp.zig:6:24: error: unable to evaluate constant expression", "tmp.zig:4:17: note: called from here", ); cases.add( "undeclared identifier error should mark fn as impure", \\export fn foo() void { \\ test_a_thing(); \\} \\fn test_a_thing() void { \\ bad_fn_call(); \\} , "tmp.zig:5:5: error: use of undeclared identifier 'bad_fn_call'", ); cases.add( "illegal comparison of types", \\fn bad_eql_1(a: []u8, b: []u8) bool { \\ return a == b; \\} \\const EnumWithData = union(enum) { \\ One: void, \\ Two: i32, \\}; \\fn bad_eql_2(a: *const EnumWithData, b: *const EnumWithData) bool { \\ return a.* == b.*; \\} \\ \\export fn entry1() usize { return @sizeOf(@typeOf(bad_eql_1)); } \\export fn entry2() usize { return @sizeOf(@typeOf(bad_eql_2)); } , "tmp.zig:2:14: error: operator not allowed for type '[]u8'", "tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'", ); cases.add( "non-const switch number literal", \\export fn foo() void { \\ const x = switch (bar()) { \\ 1, 2 => 1, \\ 3, 4 => 2, \\ else => 3, \\ }; \\} \\fn bar() i32 { \\ return 2; \\} , "tmp.zig:2:15: error: values of type 'comptime_int' must be comptime known", ); cases.add( "atomic orderings of cmpxchg - failure stricter than success", \\const AtomicOrder = @import("builtin").AtomicOrder; \\export fn f() void { \\ var x: i32 = 1234; \\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {} \\} , "tmp.zig:4:81: 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() void { \\ var x: i32 = 1234; \\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {} \\} , "tmp.zig:4:58: error: success atomic ordering must be Monotonic or stricter", ); cases.add( "negation overflow in function evaluation", \\const y = neg(-128); \\fn neg(x: i8) i8 { \\ return -x; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(y)); } , "tmp.zig:3:12: error: negation caused overflow", "tmp.zig:1:14: note: called from here", ); cases.add( "add overflow in function evaluation", \\const y = add(65530, 10); \\fn add(a: u16, b: u16) u16 { \\ return a + b; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(y)); } , "tmp.zig:3:14: error: operation caused overflow", "tmp.zig:1:14: note: called from here", ); cases.add( "sub overflow in function evaluation", \\const y = sub(10, 20); \\fn sub(a: u16, b: u16) u16 { \\ return a - b; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(y)); } , "tmp.zig:3:14: error: operation caused overflow", "tmp.zig:1:14: note: called from here", ); cases.add( "mul overflow in function evaluation", \\const y = mul(300, 6000); \\fn mul(a: u16, b: u16) u16 { \\ return a * b; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(y)); } , "tmp.zig:3:14: error: operation caused overflow", "tmp.zig:1:14: note: called from here", ); cases.add( "truncate sign mismatch", \\fn f() i8 { \\ var x: u32 = 10; \\ return @truncate(i8, x); \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:3:26: error: expected signed integer type, found 'u32'", ); cases.add( "try in function with non error return type", \\export fn f() void { \\ try something(); \\} \\fn something() anyerror!void { } , "tmp.zig:2:5: error: expected type 'void', found 'anyerror'", "tmp.zig:1:15: note: return type declared here", ); cases.add( "invalid pointer for var type", \\extern fn ext() usize; \\var bytes: [ext()]u8 = undefined; \\export fn f() void { \\ for (bytes) |*b, i| { \\ b.* = u8(i); \\ } \\} , "tmp.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{ \\ return x + y; \\} , "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'", ); cases.add( "extern function with comptime parameter", \\extern fn foo(comptime x: i32, y: i32) i32; \\fn f() i32 { \\ return foo(1, 2); \\} \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.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() void { \\ var array: [5]u8 = undefined; \\ var foo = @bytesToSlice(u32, array)[0]; \\} , "tmp.zig:3:15: error: unable to convert [5]u8 to []align(1) const u32: size mismatch", "tmp.zig:3:29: note: u32 has size 4; remaining bytes: 1", ); cases.add( "non-pure function returns type", \\var a: u32 = 0; \\pub fn List(comptime T: type) type { \\ a += 1; \\ return SmallList(T, 8); \\} \\ \\pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type { \\ return struct { \\ items: []T, \\ length: usize, \\ prealloc_items: [STATIC_SIZE]T, \\ }; \\} \\ \\export fn function_with_return_type_type() void { \\ var list: List(i32) = undefined; \\ list.length = 10; \\} , "tmp.zig:3:7: error: unable to evaluate constant expression", "tmp.zig:16:19: note: called from here", ); cases.add( "bogus method call on slice", \\var self = "aoeu"; \\fn f(m: []const u8) void { \\ m.copy(u8, self[0..], m); \\} \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:3:6: error: no member named 'copy' in '[]const u8'", ); cases.add( "wrong number of arguments for method fn call", \\const Foo = struct { \\ fn method(self: *const Foo, a: i32) void {} \\}; \\fn f(foo: *const Foo) void { \\ \\ foo.method(1, 2); \\} \\export fn entry() usize { return @sizeOf(@typeOf(f)); } , "tmp.zig:6:15: error: expected 2 arguments, found 3", ); cases.add( "assign through constant pointer", \\export fn f() void { \\ var cstr = c"Hat"; \\ cstr[0] = 'W'; \\} , "tmp.zig:3:11: error: cannot assign to constant", ); cases.add( "assign through constant slice", \\export fn f() void { \\ var cstr: []const u8 = "Hat"; \\ cstr[0] = 'W'; \\} , "tmp.zig:3:11: error: cannot assign to constant", ); cases.add( "main function with bogus args type", \\pub fn main(args: [][]bogus) !void {} , "tmp.zig:1:23: error: use of undeclared identifier 'bogus'", ); cases.add( "misspelled type with pointer only reference", \\const JasonHM = u8; \\const JasonList = *JsonNode; \\ \\const JsonOA = union(enum) { \\ JSONArray: JsonList, \\ JSONObject: JasonHM, \\}; \\ \\const JsonType = union(enum) { \\ JSONNull: void, \\ JSONInteger: isize, \\ JSONDouble: f64, \\ JSONBool: bool, \\ JSONString: []u8, \\ JSONArray: void, \\ JSONObject: void, \\}; \\ \\pub const JsonNode = struct { \\ kind: JsonType, \\ jobject: ?JsonOA, \\}; \\ \\fn foo() void { \\ var jll: JasonList = undefined; \\ jll.init(1234); \\ var jd = JsonNode {.kind = JsonType.JSONArray , .jobject = JsonOA.JSONArray {jll} }; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:5:16: error: use of undeclared identifier 'JsonList'", ); cases.add( "method call with first arg type primitive", \\const Foo = struct { \\ x: i32, \\ \\ fn init(x: i32) Foo { \\ return Foo { \\ .x = x, \\ }; \\ } \\}; \\ \\export fn f() void { \\ const derp = Foo.init(3); \\ \\ derp.init(); \\} , "tmp.zig:14:5: error: expected type 'i32', found 'Foo'", ); cases.add( "method call with first arg type wrong container", \\pub const List = struct { \\ len: usize, \\ allocator: *Allocator, \\ \\ pub fn init(allocator: *Allocator) List { \\ return List { \\ .len = 0, \\ .allocator = allocator, \\ }; \\ } \\}; \\ \\pub var global_allocator = Allocator { \\ .field = 1234, \\}; \\ \\pub const Allocator = struct { \\ field: i32, \\}; \\ \\export fn foo() void { \\ var x = List.init(&global_allocator); \\ x.init(); \\} , "tmp.zig:23:5: error: expected type '*Allocator', found '*List'", ); cases.add( "binary not on number literal", \\const TINY_QUANTUM_SHIFT = 4; \\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 { return @sizeOf(@typeOf(block_aligned_stuff)); } , "tmp.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'", ); cases.addCase(x: { const tc = cases.create( "multiple files with private function error", \\const foo = @import("foo.zig",); \\ \\export fn callPrivFunction() void { \\ foo.privateFunction(); \\} , "tmp.zig:4:8: error: 'privateFunction' is private", "foo.zig:1:1: note: declared here", ); tc.addSourceFile("foo.zig", \\fn privateFunction() void { } ); break :x tc; }); cases.add( "container init with non-type", \\const zero: i32 = 0; \\const a = zero{1}; \\ \\export fn entry() usize { return @sizeOf(@typeOf(a)); } , "tmp.zig:2:11: error: expected type 'type', found 'i32'", ); cases.add( "assign to constant field", \\const Foo = struct { \\ field: i32, \\}; \\export fn derp() void { \\ const f = Foo {.field = 1234,}; \\ f.field = 0; \\} , "tmp.zig:6:13: error: cannot assign to constant", ); cases.add( "return from defer expression", \\pub fn testTrickyDefer() !void { \\ defer canFail() catch {}; \\ \\ defer try canFail(); \\ \\ const a = maybeInt() orelse return; \\} \\ \\fn canFail() anyerror!void { } \\ \\pub fn maybeInt() ?i32 { \\ return 0; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(testTrickyDefer)); } , "tmp.zig:4:11: error: cannot return from defer expression", ); cases.add( "attempt to access var args out of bounds", \\fn add(args: ...) i32 { \\ return args[0] + args[1]; \\} \\ \\fn foo() i32 { \\ return add(i32(1234)); \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:2:26: error: index 1 outside argument list of size 1", "tmp.zig:6:15: note: called from here", ); cases.add( "pass integer literal to var args", \\fn add(args: ...) i32 { \\ var sum = i32(0); \\ {comptime var i: usize = 0; inline while (i < args.len) : (i += 1) { \\ sum += args[i]; \\ }} \\ return sum; \\} \\ \\fn bar() i32 { \\ return add(1, 2, 3, 4); \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(bar)); } , "tmp.zig:10:16: error: compiler bug: integer and float literals in var args function must be casted", ); cases.add( "assign too big number to u16", \\export fn foo() void { \\ var vga_mem: u16 = 0xB8000; \\} , "tmp.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 { return @sizeOf(@typeOf(some_data)); } , "tmp.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) void; \\export fn entry() void { return foo(); } , "tmp.zig:1:23: error: alignment value 3 is not a power of 2", ); cases.add( "compile log", \\export fn foo() void { \\ comptime bar(12, "hi",); \\} \\fn bar(a: i32, b: []const u8) void { \\ @compileLog("begin",); \\ @compileLog("a", a, "b", b); \\ @compileLog("end",); \\} , "tmp.zig:5:5: error: found compile log statement", "tmp.zig:6:5: error: found compile log statement", "tmp.zig:7:5: error: found compile log statement", ); cases.add( "casting bit offset pointer to regular pointer", \\const BitField = packed struct { \\ a: u3, \\ b: u3, \\ c: u2, \\}; \\ \\fn foo(bit_field: *const BitField) u3 { \\ return bar(&bit_field.b); \\} \\ \\fn bar(x: *const u3) u3 { \\ return x.*; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:8:26: error: expected type '*const u3', found '*align(:3:1) const u3'", ); cases.add( "referring to a struct that is invalid", \\const UsbDeviceRequest = struct { \\ Type: u8, \\}; \\ \\export fn foo() void { \\ comptime assert(@sizeOf(UsbDeviceRequest) == 0x8); \\} \\ \\fn assert(ok: bool) void { \\ if (!ok) unreachable; \\} , "tmp.zig:10:14: error: unable to evaluate constant expression", "tmp.zig:6:20: note: called from here", ); cases.add( "control flow uses comptime var at runtime", \\export fn foo() void { \\ comptime var i = 0; \\ while (i < 5) : (i += 1) { \\ bar(); \\ } \\} \\ \\fn bar() void { } , "tmp.zig:3:5: error: control flow attempts to use compile-time variable at runtime", "tmp.zig:3:24: note: compile-time variable assigned here", ); cases.add( "ignored return value", \\export fn foo() void { \\ bar(); \\} \\fn bar() i32 { return 0; } , "tmp.zig:2:8: error: expression value is ignored", ); cases.add( "ignored assert-err-ok return value", \\export fn foo() void { \\ bar() catch unreachable; \\} \\fn bar() anyerror!i32 { return 0; } , "tmp.zig:2:11: error: expression value is ignored", ); cases.add( "ignored statement value", \\export fn foo() void { \\ 1; \\} , "tmp.zig:2:5: error: expression value is ignored", ); cases.add( "ignored comptime statement value", \\export fn foo() void { \\ comptime {1;} \\} , "tmp.zig:2:15: error: expression value is ignored", ); cases.add( "ignored comptime value", \\export fn foo() void { \\ comptime 1; \\} , "tmp.zig:2:5: error: expression value is ignored", ); cases.add( "ignored defered statement value", \\export fn foo() void { \\ defer {1;} \\} , "tmp.zig:2:12: error: expression value is ignored", ); cases.add( "ignored defered function call", \\export fn foo() void { \\ defer bar(); \\} \\fn bar() anyerror!i32 { return 0; } , "tmp.zig:2:14: error: expression value is ignored", ); cases.add( "dereference an array", \\var s_buffer: [10]u8 = undefined; \\pub fn pass(in: []u8) []u8 { \\ var out = &s_buffer; \\ out.*.* = in[0]; \\ return out.*[0..1]; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(pass)); } , "tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'", ); cases.add( "pass const ptr to mutable ptr fn", \\fn foo() bool { \\ const a = ([]const u8)("a",); \\ const b = &a; \\ return ptrEql(b, b); \\} \\fn ptrEql(a: *[]const u8, b: *[]const u8) bool { \\ return true; \\} \\ \\export fn entry() usize { return @sizeOf(@typeOf(foo)); } , "tmp.zig:4:19: error: expected type '*[]const u8', found '*const []const u8'", ); cases.addCase(x: { const tc = cases.create( "export collision", \\const foo = @import("foo.zig",); \\ \\export fn bar() usize { \\ return foo.baz; \\} , "foo.zig:1:1: error: exported symbol collision: 'bar'", "tmp.zig:3:1: note: other symbol here", ); tc.addSourceFile("foo.zig", \\export fn bar() void {} \\pub const baz = 1234; ); break :x tc; }); cases.add( "implicit cast from array to mutable slice", \\var global_array: [10]i32 = undefined; \\fn foo(param: []i32) void {} \\export fn entry() void { \\ foo(global_array); \\} , "tmp.zig:4:9: error: expected type '[]i32', found '[10]i32'", ); cases.add( "ptrcast to non-pointer", \\export fn entry(a: *i32) usize { \\ return @ptrCast(usize, a); \\} , "tmp.zig:2:21: error: expected pointer, found 'usize'", ); cases.add( "asm at compile time", \\comptime { \\ doSomeAsm(); \\} \\ \\fn doSomeAsm() void { \\ asm volatile ( \\ \\.globl aoeu; \\ \\.type aoeu, @function; \\ \\.set aoeu, derp; \\ ); \\} , "tmp.zig:6:5: error: unable to evaluate constant expression", ); cases.add( "invalid member of builtin enum", \\const builtin = @import("builtin",); \\export fn entry() void { \\ const foo = builtin.Arch.x86; \\} , "tmp.zig:3:29: error: container 'builtin.Arch' has no member called 'x86'", ); cases.add( "int to ptr of 0 bits", \\export fn foo() void { \\ var x: usize = 0x1000; \\ var y: *void = @intToPtr(*void, x); \\} , "tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information", ); cases.add( "@fieldParentPtr - non struct", \\const Foo = i32; \\export fn foo(a: *i32) *Foo { \\ return @fieldParentPtr(Foo, "a", a); \\} , "tmp.zig:3:28: error: expected struct type, found 'i32'", ); cases.add( "@fieldParentPtr - bad field name", \\const Foo = extern struct { \\ derp: i32, \\}; \\export fn foo(a: *i32) *Foo { \\ return @fieldParentPtr(Foo, "a", a); \\} , "tmp.zig:5:33: error: struct 'Foo' has no field 'a'", ); cases.add( "@fieldParentPtr - field pointer is not pointer", \\const Foo = extern struct { \\ a: i32, \\}; \\export fn foo(a: i32) *Foo { \\ return @fieldParentPtr(Foo, "a", a); \\} , "tmp.zig:5:38: error: expected pointer, found 'i32'", ); cases.add( "@fieldParentPtr - comptime field ptr not based on struct", \\const Foo = struct { \\ a: i32, \\ b: i32, \\}; \\const foo = Foo { .a = 1, .b = 2, }; \\ \\comptime { \\ const field_ptr = @intToPtr(*i32, 0x1234); \\ const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr); \\} , "tmp.zig:9:55: error: pointer value not based on parent struct", ); cases.add( "@fieldParentPtr - comptime wrong field index", \\const Foo = struct { \\ a: i32, \\ b: i32, \\}; \\const foo = Foo { .a = 1, .b = 2, }; \\ \\comptime { \\ const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a); \\} , "tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'", ); cases.add( "@byteOffsetOf - non struct", \\const Foo = i32; \\export fn foo() usize { \\ return @byteOffsetOf(Foo, "a",); \\} , "tmp.zig:3:26: error: expected struct type, found 'i32'", ); cases.add( "@byteOffsetOf - bad field name", \\const Foo = struct { \\ derp: i32, \\}; \\export fn foo() usize { \\ return @byteOffsetOf(Foo, "a",); \\} , "tmp.zig:5:31: error: struct 'Foo' has no field 'a'", ); cases.addExe( "missing main fn in executable", \\ , "error: root source file has no member called 'main'", ); cases.addExe( "private main fn", \\fn main() void {} , "error: 'main' is private", "tmp.zig:1:1: note: declared here", ); cases.add( "setting a section on an extern variable", \\extern var foo: i32 linksection(".text2"); \\export fn entry() i32 { \\ return foo; \\} , "tmp.zig:1:33: error: cannot set section of external variable 'foo'", ); cases.add( "setting a section on a local variable", \\export fn entry() i32 { \\ var foo: i32 linksection(".text2") = 1234; \\ return foo; \\} , "tmp.zig:2:30: error: cannot set section of local variable 'foo'", ); cases.add( "setting a section on an extern fn", \\extern fn foo() linksection(".text2") void; \\export fn entry() void { \\ foo(); \\} , "tmp.zig:1:29: error: cannot set section of external function 'foo'", ); cases.add( "returning address of local variable - simple", \\export fn foo() *i32 { \\ var a: i32 = undefined; \\ return &a; \\} , "tmp.zig:3:13: error: function returns address of local variable", ); cases.add( "returning address of local variable - phi", \\export fn foo(c: bool) *i32 { \\ var a: i32 = undefined; \\ var b: i32 = undefined; \\ return if (c) &a else &b; \\} , "tmp.zig:4:12: error: function returns address of local variable", ); cases.add( "inner struct member shadowing outer struct member", \\fn A() type { \\ return struct { \\ b: B(), \\ \\ const Self = @This(); \\ \\ fn B() type { \\ return struct { \\ const Self = @This(); \\ }; \\ } \\ }; \\} \\comptime { \\ assert(A().B().Self != A().Self); \\} \\fn assert(ok: bool) void { \\ if (!ok) unreachable; \\} , "tmp.zig:9:17: error: redefinition of 'Self'", "tmp.zig:5:9: note: previous definition is here", ); cases.add( "while expected bool, got optional", \\export fn foo() void { \\ while (bar()) {} \\} \\fn bar() ?i32 { return 1; } , "tmp.zig:2:15: error: expected type 'bool', found '?i32'", ); cases.add( "while expected bool, got error union", \\export fn foo() void { \\ while (bar()) {} \\} \\fn bar() anyerror!i32 { return 1; } , "tmp.zig:2:15: error: expected type 'bool', found 'anyerror!i32'", ); cases.add( "while expected optional, got bool", \\export fn foo() void { \\ while (bar()) |x| {} \\} \\fn bar() bool { return true; } , "tmp.zig:2:15: error: expected optional type, found 'bool'", ); cases.add( "while expected optional, got error union", \\export fn foo() void { \\ while (bar()) |x| {} \\} \\fn bar() anyerror!i32 { return 1; } , "tmp.zig:2:15: error: expected optional type, found 'anyerror!i32'", ); cases.add( "while expected error union, got bool", \\export fn foo() void { \\ while (bar()) |x| {} else |err| {} \\} \\fn bar() bool { return true; } , "tmp.zig:2:15: error: expected error union type, found 'bool'", ); cases.add( "while expected error union, got optional", \\export fn foo() void { \\ while (bar()) |x| {} else |err| {} \\} \\fn bar() ?i32 { return 1; } , "tmp.zig:2:15: error: expected error union type, found '?i32'", ); cases.add( "inline fn calls itself indirectly", \\export fn foo() void { \\ bar(); \\} \\inline fn bar() void { \\ baz(); \\ quux(); \\} \\inline fn baz() void { \\ bar(); \\ quux(); \\} \\extern fn quux() void; , "tmp.zig:4:1: error: unable to inline function", ); cases.add( "save reference to inline function", \\export fn foo() void { \\ quux(@ptrToInt(bar)); \\} \\inline fn bar() void { } \\extern fn quux(usize) void; , "tmp.zig:4:1: error: unable to inline function", ); cases.add( "signed integer division", \\export fn foo(a: i32, b: i32) i32 { \\ return a / b; \\} , "tmp.zig:2:14: 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 { \\ return a % b; \\} , "tmp.zig:2:14: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod", ); cases.add( "compile-time division by zero", \\comptime { \\ const a: i32 = 1; \\ const b: i32 = 0; \\ const c = a / b; \\} , "tmp.zig:4:17: error: division by zero", ); cases.add( "compile-time remainder division by zero", \\comptime { \\ const a: i32 = 1; \\ const b: i32 = 0; \\ const c = a % b; \\} , "tmp.zig:4:17: error: division by zero", ); cases.add( "@setRuntimeSafety twice for same scope", \\export fn foo() void { \\ @setRuntimeSafety(false); \\ @setRuntimeSafety(false); \\} , "tmp.zig:3:5: error: runtime safety set twice for same scope", "tmp.zig:2:5: note: first set here", ); cases.add( "@setFloatMode twice for same scope", \\export fn foo() void { \\ @setFloatMode(@import("builtin").FloatMode.Optimized); \\ @setFloatMode(@import("builtin").FloatMode.Optimized); \\} , "tmp.zig:3:5: error: float mode set twice for same scope", "tmp.zig:2:5: note: first set here", ); cases.add( "array access of type", \\export fn foo() void { \\ var b: u8[40] = undefined; \\} , "tmp.zig:2:14: error: array access of non-array type 'type'", ); cases.add( "cannot break out of defer expression", \\export fn foo() void { \\ while (true) { \\ defer { \\ break; \\ } \\ } \\} , "tmp.zig:4:13: error: cannot break out of defer expression", ); cases.add( "cannot continue out of defer expression", \\export fn foo() void { \\ while (true) { \\ defer { \\ continue; \\ } \\ } \\} , "tmp.zig:4:13: error: cannot continue out of defer expression", ); cases.add( "calling a var args function only known at runtime", \\var foos = []fn(...) void { foo1, foo2 }; \\ \\fn foo1(args: ...) void {} \\fn foo2(args: ...) void {} \\ \\pub fn main() !void { \\ foos[0](); \\} , "tmp.zig:7:9: error: calling a generic function requires compile-time known function value", ); cases.add( "calling a generic function only known at runtime", \\var foos = []fn(var) void { foo1, foo2 }; \\ \\fn foo1(arg: var) void {} \\fn foo2(arg: var) void {} \\ \\pub fn main() !void { \\ foos[0](true); \\} , "tmp.zig:7:9: error: calling a generic function requires compile-time known function value", ); cases.add( "@compileError shows traceback of references that caused it", \\const foo = @compileError("aoeu",); \\ \\const bar = baz + foo; \\const baz = 1; \\ \\export fn entry() i32 { \\ return bar; \\} , "tmp.zig:1:13: error: aoeu", "tmp.zig:3:19: note: referenced here", "tmp.zig:7:12: note: referenced here", ); cases.add( "float literal too large error", \\comptime { \\ const a = 0x1.0p16384; \\} , "tmp.zig:2:15: error: float literal out of range of any type", ); cases.add( "float literal too small error (denormal)", \\comptime { \\ const a = 0x1.0p-16384; \\} , "tmp.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 { \\ return i32(12.34); \\} , "tmp.zig:2:16: 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 { \\ return @ptrToInt(x); \\} , "tmp.zig:2:22: error: expected pointer, found 'i32'", ); cases.add( "@shlExact shifts out 1 bits", \\comptime { \\ const x = @shlExact(u8(0b01010101), 2); \\} , "tmp.zig:2:15: error: operation caused overflow", ); cases.add( "@shrExact shifts out 1 bits", \\comptime { \\ const x = @shrExact(u8(0b10101010), 2); \\} , "tmp.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 { \\ return 0x11 << x; \\} , "tmp.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 { \\ return x << y; \\} , "tmp.zig:2:17: error: expected type 'u3', found 'u8'", ); cases.add( "globally shadowing a primitive type", \\const u16 = @intType(false, 8); \\export fn entry() void { \\ const a: u16 = 300; \\} , "tmp.zig:1:1: error: declaration shadows primitive type 'u16'", ); cases.add( "implicitly increasing pointer alignment", \\const Foo = packed struct { \\ a: u8, \\ b: u32, \\}; \\ \\export fn entry() void { \\ var foo = Foo { .a = 1, .b = 10 }; \\ bar(&foo.b); \\} \\ \\fn bar(x: *u32) void { \\ x.* += 1; \\} , "tmp.zig:8:13: error: expected type '*u32', found '*align(1) u32'", ); cases.add( "implicitly increasing slice alignment", \\const Foo = packed struct { \\ a: u8, \\ b: u32, \\}; \\ \\export fn entry() void { \\ var foo = Foo { .a = 1, .b = 10 }; \\ foo.b += 1; \\ bar((*[1]u32)(&foo.b)[0..]); \\} \\ \\fn bar(x: []u32) void { \\ x[0] += 1; \\} , "tmp.zig:9:18: error: cast increases pointer alignment", "tmp.zig:9:23: note: '*align(1) u32' has alignment 1", "tmp.zig:9:18: note: '*[1]u32' has alignment 4", ); cases.add( "increase pointer alignment in @ptrCast", \\export fn entry() u32 { \\ var bytes: [4]u8 = []u8{0x01, 0x02, 0x03, 0x04}; \\ const ptr = @ptrCast(*u32, &bytes[0]); \\ return ptr.*; \\} , "tmp.zig:3:17: error: cast increases pointer alignment", "tmp.zig:3:38: note: '*u8' has alignment 1", "tmp.zig:3:26: note: '*u32' has alignment 4", ); cases.add( "@alignCast expects pointer or slice", \\export fn entry() void { \\ @alignCast(4, u32(3)); \\} , "tmp.zig:2:22: error: expected pointer or slice, found 'u32'", ); cases.add( "passing an under-aligned function pointer", \\export fn entry() void { \\ testImplicitlyDecreaseFnAlign(alignedSmall, 1234); \\} \\fn testImplicitlyDecreaseFnAlign(ptr: fn () align(8) i32, answer: i32) void { \\ if (ptr() != answer) unreachable; \\} \\fn alignedSmall() align(4) i32 { return 1234; } , "tmp.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 { \\ var x: i32 align(1) = 1234; \\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {} \\ return x == 5678; \\} , "tmp.zig:4:32: error: expected type '*i32', found '*align(1) i32'", ); cases.add( "wrong size to an array literal", \\comptime { \\ const array = [2]u8{1, 2, 3}; \\} , "tmp.zig:2:24: error: expected [2]u8 literal, found [3]u8 literal", ); cases.add( "wrong pointer implicitly casted to pointer to @OpaqueType()", \\const Derp = @OpaqueType(); \\extern fn bar(d: *Derp) void; \\export fn foo() void { \\ var x = u8(1); \\ bar(@ptrCast(*c_void, &x)); \\} , "tmp.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) void { \\ var m2 = &2; \\ const y: u32 = m2.*; \\ \\ var a = undefined; \\ var b = 1; \\ var c = 1.0; \\ var d = null; \\ var e = opaque.*; \\ var f = i32; \\ var h = (Foo {}).bar; \\ \\ var z: noreturn = return; \\} \\ \\const Foo = struct { \\ fn bar(self: *const Foo) void {} \\}; , "tmp.zig:4:4: error: variable of type '*comptime_int' must be const or comptime", "tmp.zig:7:4: error: variable of type '(undefined)' must be const or comptime", "tmp.zig:8:4: error: variable of type 'comptime_int' must be const or comptime", "tmp.zig:9:4: error: variable of type 'comptime_float' must be const or comptime", "tmp.zig:10:4: error: variable of type '(null)' must be const or comptime", "tmp.zig:11:4: error: variable of type 'Opaque' not allowed", "tmp.zig:12:4: error: variable of type 'type' must be const or comptime", "tmp.zig:13:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime", "tmp.zig:15:4: error: unreachable code", ); cases.add( "wrong types given to atomic order args in cmpxchg", \\export fn entry() void { \\ var x: i32 = 1234; \\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, u32(1234), u32(1234))) {} \\} , "tmp.zig:3:50: error: expected type 'builtin.AtomicOrder', found 'u32'", ); cases.add( "wrong types given to @export", \\extern fn entry() void { } \\comptime { \\ @export("entry", entry, u32(1234)); \\} , "tmp.zig:3:32: error: expected type 'builtin.GlobalLinkage', found 'u32'", ); cases.add( "struct with invalid field", \\const std = @import("std",); \\const Allocator = std.mem.Allocator; \\const ArrayList = std.ArrayList; \\ \\const HeaderWeight = enum { \\ H1, H2, H3, H4, H5, H6, \\}; \\ \\const MdText = ArrayList(u8); \\ \\const MdNode = union(enum) { \\ Header: struct { \\ text: MdText, \\ weight: HeaderValue, \\ }, \\}; \\ \\export fn entry() void { \\ const a = MdNode.Header { \\ .text = MdText.init(&std.debug.global_allocator), \\ .weight = HeaderWeight.H1, \\ }; \\} , "tmp.zig:14:17: error: use of undeclared identifier 'HeaderValue'", ); cases.add( "@setAlignStack outside function", \\comptime { \\ @setAlignStack(16); \\} , "tmp.zig:2:5: error: @setAlignStack outside function", ); cases.add( "@setAlignStack in naked function", \\export nakedcc fn entry() void { \\ @setAlignStack(16); \\} , "tmp.zig:2:5: error: @setAlignStack in naked function", ); cases.add( "@setAlignStack in inline function", \\export fn entry() void { \\ foo(); \\} \\inline fn foo() void { \\ @setAlignStack(16); \\} , "tmp.zig:5:5: error: @setAlignStack in inline function", ); cases.add( "@setAlignStack set twice", \\export fn entry() void { \\ @setAlignStack(16); \\ @setAlignStack(16); \\} , "tmp.zig:3:5: error: alignstack set twice", "tmp.zig:2:5: note: first set here", ); cases.add( "@setAlignStack too big", \\export fn entry() void { \\ @setAlignStack(511 + 1); \\} , "tmp.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256", ); cases.add( "storing runtime value in compile time variable then using it", \\const Mode = @import("builtin").Mode; \\ \\fn Free(comptime filename: []const u8) TestCase { \\ return TestCase { \\ .filename = filename, \\ .problem_type = ProblemType.Free, \\ }; \\} \\ \\fn LibC(comptime filename: []const u8) TestCase { \\ return TestCase { \\ .filename = filename, \\ .problem_type = ProblemType.LinkLibC, \\ }; \\} \\ \\const TestCase = struct { \\ filename: []const u8, \\ problem_type: ProblemType, \\}; \\ \\const ProblemType = enum { \\ Free, \\ LinkLibC, \\}; \\ \\export fn entry() void { \\ const tests = []TestCase { \\ Free("001"), \\ Free("002"), \\ LibC("078"), \\ Free("116"), \\ Free("117"), \\ }; \\ \\ for ([]Mode { Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast }) |mode| { \\ inline for (tests) |test_case| { \\ const foo = test_case.filename ++ ".zig"; \\ } \\ } \\} , "tmp.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 { \\ var x: i32 = 1; \\ return bar(@ptrCast(*MyType, &x)); \\} \\ \\fn bar(x: *MyType) bool { \\ return x.blah; \\} , "tmp.zig:9:13: error: type '*MyType' does not support field access", ); cases.add( "carriage return special case", "fn test() bool {\r\n" ++ " true\r\n" ++ "}\r\n", "tmp.zig:1:17: error: invalid carriage return, only '\\n' line endings are supported", ); cases.add( "non-printable invalid character", "\xff\xfe" ++ \\fn test() bool {\r \\ true\r \\} , "tmp.zig:1:1: error: invalid character: '\\xff'", ); cases.add( "non-printable invalid character with escape alternative", "fn test() bool {\n" ++ "\ttrue\n" ++ "}\n", "tmp.zig:2:1: error: invalid character: '\\t'", ); cases.add( "@ArgType given non function parameter", \\comptime { \\ _ = @ArgType(i32, 3); \\} , "tmp.zig:2:18: error: expected function, found 'i32'", ); cases.add( "@ArgType arg index out of bounds", \\comptime { \\ _ = @ArgType(@typeOf(add), 2); \\} \\fn add(a: i32, b: i32) i32 { return a + b; } , "tmp.zig:2:32: error: arg index 2 out of bounds; 'fn(i32, i32) i32' has 2 arguments", ); cases.add( "@memberType on unsupported type", \\comptime { \\ _ = @memberType(i32, 0); \\} , "tmp.zig:2:21: error: type 'i32' does not support @memberType", ); cases.add( "@memberType on enum", \\comptime { \\ _ = @memberType(Foo, 0); \\} \\const Foo = enum {A,}; , "tmp.zig:2:21: error: type 'Foo' does not support @memberType", ); cases.add( "@memberType struct out of bounds", \\comptime { \\ _ = @memberType(Foo, 0); \\} \\const Foo = struct {}; , "tmp.zig:2:26: error: member index 0 out of bounds; 'Foo' has 0 members", ); cases.add( "@memberType union out of bounds", \\comptime { \\ _ = @memberType(Foo, 1); \\} \\const Foo = union {A: void,}; , "tmp.zig:2:26: error: member index 1 out of bounds; 'Foo' has 1 members", ); cases.add( "@memberName on unsupported type", \\comptime { \\ _ = @memberName(i32, 0); \\} , "tmp.zig:2:21: error: type 'i32' does not support @memberName", ); cases.add( "@memberName struct out of bounds", \\comptime { \\ _ = @memberName(Foo, 0); \\} \\const Foo = struct {}; , "tmp.zig:2:26: error: member index 0 out of bounds; 'Foo' has 0 members", ); cases.add( "@memberName enum out of bounds", \\comptime { \\ _ = @memberName(Foo, 1); \\} \\const Foo = enum {A,}; , "tmp.zig:2:26: error: member index 1 out of bounds; 'Foo' has 1 members", ); cases.add( "@memberName union out of bounds", \\comptime { \\ _ = @memberName(Foo, 1); \\} \\const Foo = union {A:i32,}; , "tmp.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() void { \\ foo("hello",); \\} \\pub extern fn foo(format: *const u8, ...) void; , "tmp.zig:2:9: error: expected type '*const u8', found '[5]u8'", ); cases.add( "constant inside comptime function has compile error", \\const ContextAllocator = MemoryPool(usize); \\ \\pub fn MemoryPool(comptime T: type) type { \\ const free_list_t = @compileError("aoeu",); \\ \\ return struct { \\ free_list: free_list_t, \\ }; \\} \\ \\export fn entry() void { \\ var allocator: ContextAllocator = undefined; \\} , "tmp.zig:4:25: error: aoeu", "tmp.zig:1:36: note: called from here", "tmp.zig:12:20: note: referenced here", ); cases.add( "specify enum tag type that is too small", \\const Small = enum (u2) { \\ One, \\ Two, \\ Three, \\ Four, \\ Five, \\}; \\ \\export fn entry() void { \\ var x = Small.One; \\} , "tmp.zig:1:21: error: 'u2' too small to hold all bits; must be at least 'u3'", ); cases.add( "specify non-integer enum tag type", \\const Small = enum (f32) { \\ One, \\ Two, \\ Three, \\}; \\ \\export fn entry() void { \\ var x = Small.One; \\} , "tmp.zig:1:21: error: expected integer, found 'f32'", ); cases.add( "implicitly casting enum to tag type", \\const Small = enum(u2) { \\ One, \\ Two, \\ Three, \\ Four, \\}; \\ \\export fn entry() void { \\ var x: u2 = Small.Two; \\} , "tmp.zig:9:22: error: expected type 'u2', found 'Small'", ); cases.add( "explicitly casting non tag type to enum", \\const Small = enum(u2) { \\ One, \\ Two, \\ Three, \\ Four, \\}; \\ \\export fn entry() void { \\ var y = u3(3); \\ var x = @intToEnum(Small, y); \\} , "tmp.zig:10:31: error: expected type 'u2', found 'u3'", ); cases.add( "non unsigned integer enum tag type", \\const Small = enum(i2) { \\ One, \\ Two, \\ Three, \\ Four, \\}; \\ \\export fn entry() void { \\ var y = Small.Two; \\} , "tmp.zig:1:20: error: expected unsigned integer, found 'i2'", ); cases.add( "struct fields with value assignments", \\const MultipleChoice = struct { \\ A: i32 = 20, \\}; \\export fn entry() void { \\ var x: MultipleChoice = undefined; \\} , "tmp.zig:2:14: error: enums, not structs, support field assignment", ); cases.add( "union fields with value assignments", \\const MultipleChoice = union { \\ A: i32 = 20, \\}; \\export fn entry() void { \\ var x: MultipleChoice = undefined; \\} , "tmp.zig:2:14: error: non-enum union field assignment", "tmp.zig:1:24: note: consider 'union(enum)' here", ); cases.add( "enum with 0 fields", \\const Foo = enum {}; \\export fn entry() usize { \\ return @sizeOf(Foo); \\} , "tmp.zig:1:13: error: enums must have 1 or more fields", ); cases.add( "union with 0 fields", \\const Foo = union {}; \\export fn entry() usize { \\ return @sizeOf(Foo); \\} , "tmp.zig:1:13: error: unions must have 1 or more fields", ); cases.add( "enum value already taken", \\const MultipleChoice = enum(u32) { \\ A = 20, \\ B = 40, \\ C = 60, \\ D = 1000, \\ E = 60, \\}; \\export fn entry() void { \\ var x = MultipleChoice.C; \\} , "tmp.zig:6:9: error: enum tag value 60 already taken", "tmp.zig:4:9: note: other occurrence here", ); cases.add( "union with specified enum omits field", \\const Letter = enum { \\ A, \\ B, \\ C, \\}; \\const Payload = union(Letter) { \\ A: i32, \\ B: f64, \\}; \\export fn entry() usize { \\ return @sizeOf(Payload); \\} , "tmp.zig:6:17: error: enum field missing: 'C'", "tmp.zig:4:5: note: declared here", ); cases.add( "@TagType when union has no attached enum", \\const Foo = union { \\ A: i32, \\}; \\export fn entry() void { \\ const x = @TagType(Foo); \\} , "tmp.zig:5:24: error: union 'Foo' has no tag", "tmp.zig:1:13: note: consider 'union(enum)' here", ); cases.add( "non-integer tag type to automatic union enum", \\const Foo = union(enum(f32)) { \\ A: i32, \\}; \\export fn entry() void { \\ const x = @TagType(Foo); \\} , "tmp.zig:1:24: error: expected integer tag type, found 'f32'", ); cases.add( "non-enum tag type passed to union", \\const Foo = union(u32) { \\ A: i32, \\}; \\export fn entry() void { \\ const x = @TagType(Foo); \\} , "tmp.zig:1:19: error: expected enum tag type, found 'u32'", ); cases.add( "union auto-enum value already taken", \\const MultipleChoice = union(enum(u32)) { \\ A = 20, \\ B = 40, \\ C = 60, \\ D = 1000, \\ E = 60, \\}; \\export fn entry() void { \\ var x = MultipleChoice { .C = {} }; \\} , "tmp.zig:6:9: error: enum tag value 60 already taken", "tmp.zig:4:9: note: other occurrence here", ); cases.add( "union enum field does not match enum", \\const Letter = enum { \\ A, \\ B, \\ C, \\}; \\const Payload = union(Letter) { \\ A: i32, \\ B: f64, \\ C: bool, \\ D: bool, \\}; \\export fn entry() void { \\ var a = Payload {.A = 1234}; \\} , "tmp.zig:10:5: error: enum field not found: 'D'", "tmp.zig:1:16: note: enum declared here", ); cases.add( "field type supplied in an enum", \\const Letter = enum { \\ A: void, \\ B, \\ C, \\}; \\export fn entry() void { \\ var b = Letter.B; \\} , "tmp.zig:2:8: error: structs and unions, not enums, support field types", "tmp.zig:1:16: note: consider 'union(enum)' here", ); cases.add( "struct field missing type", \\const Letter = struct { \\ A, \\}; \\export fn entry() void { \\ var a = Letter { .A = {} }; \\} , "tmp.zig:2:5: error: struct field missing type", ); cases.add( "extern union field missing type", \\const Letter = extern union { \\ A, \\}; \\export fn entry() void { \\ var a = Letter { .A = {} }; \\} , "tmp.zig:2:5: error: union field missing type", ); cases.add( "extern union given enum tag type", \\const Letter = enum { \\ A, \\ B, \\ C, \\}; \\const Payload = extern union(Letter) { \\ A: i32, \\ B: f64, \\ C: bool, \\}; \\export fn entry() void { \\ var a = Payload { .A = 1234 }; \\} , "tmp.zig:6:30: error: extern union does not support enum tag type", ); cases.add( "packed union given enum tag type", \\const Letter = enum { \\ A, \\ B, \\ C, \\}; \\const Payload = packed union(Letter) { \\ A: i32, \\ B: f64, \\ C: bool, \\}; \\export fn entry() void { \\ var a = Payload { .A = 1234 }; \\} , "tmp.zig:6:30: error: packed union does not support enum tag type", ); cases.add( "switch on union with no attached enum", \\const Payload = union { \\ A: i32, \\ B: f64, \\ C: bool, \\}; \\export fn entry() void { \\ const a = Payload { .A = 1234 }; \\ foo(a); \\} \\fn foo(a: *const Payload) void { \\ switch (a.*) { \\ Payload.A => {}, \\ else => unreachable, \\ } \\} , "tmp.zig:11:14: error: switch on union which has no attached enum", "tmp.zig:1:17: note: consider 'union(enum)' here", ); cases.add( "enum in field count range but not matching tag", \\const Foo = enum(u32) { \\ A = 10, \\ B = 11, \\}; \\export fn entry() void { \\ var x = @intToEnum(Foo, 0); \\} , "tmp.zig:6:13: error: enum 'Foo' has no tag matching integer value 0", "tmp.zig:1:13: note: 'Foo' declared here", ); cases.add( "comptime cast enum to union but field has payload", \\const Letter = enum { A, B, C }; \\const Value = union(Letter) { \\ A: i32, \\ B, \\ C, \\}; \\export fn entry() void { \\ var x: Value = Letter.A; \\} , "tmp.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'", "tmp.zig:3:5: note: field 'A' declared here", ); cases.add( "runtime cast to union which has non-void fields", \\const Letter = enum { A, B, C }; \\const Value = union(Letter) { \\ A: i32, \\ B, \\ C, \\}; \\export fn entry() void { \\ foo(Letter.A); \\} \\fn foo(l: Letter) void { \\ var x: Value = l; \\} , "tmp.zig:11:20: error: runtime cast to union 'Value' which has non-void fields", "tmp.zig:3:5: note: field 'A' has type 'i32'", ); cases.add( "taking byte offset of void field in struct", \\const Empty = struct { \\ val: void, \\}; \\export fn foo() void { \\ const fieldOffset = @byteOffsetOf(Empty, "val",); \\} , "tmp.zig:5:46: error: zero-bit field 'val' in struct 'Empty' has no offset", ); cases.add( "taking bit offset of void field in struct", \\const Empty = struct { \\ val: void, \\}; \\export fn foo() void { \\ const fieldOffset = @bitOffsetOf(Empty, "val",); \\} , "tmp.zig:5:45: error: zero-bit field 'val' in struct 'Empty' has no offset", ); cases.add( "invalid union field access in comptime", \\const Foo = union { \\ Bar: u8, \\ Baz: void, \\}; \\comptime { \\ var foo = Foo {.Baz = {}}; \\ const bar_val = foo.Bar; \\} , "tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set", ); cases.add( "getting return type of generic function", \\fn generic(a: var) void {} \\comptime { \\ _ = @typeOf(generic).ReturnType; \\} , "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(var)var' is generic", ); cases.add( "getting @ArgType of generic function", \\fn generic(a: var) void {} \\comptime { \\ _ = @ArgType(@typeOf(generic), 0); \\} , "tmp.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic", ); cases.add( "unsupported modifier at start of asm output constraint", \\export fn foo() void { \\ var bar: u32 = 3; \\ asm volatile ("" : [baz]"+r"(bar) : : ""); \\} , "tmp.zig:3:5: error: invalid modifier starting output constraint for 'baz': '+', only '=' is supported. Compiler TODO: see https://github.com/ziglang/zig/issues/215", ); cases.add( "comptime_int in asm input", \\export fn foo() void { \\ asm volatile ("" : : [bar]"r"(3) : ""); \\} , "tmp.zig:2:35: error: expected sized integer or sized float, found comptime_int", ); cases.add( "comptime_float in asm input", \\export fn foo() void { \\ asm volatile ("" : : [bar]"r"(3.17) : ""); \\} , "tmp.zig:2:35: error: expected sized integer or sized float, found comptime_float", ); cases.add( "runtime assignment to comptime struct type", \\const Foo = struct { \\ Bar: u8, \\ Baz: type, \\}; \\export fn f() void { \\ var x: u8 = 0; \\ const foo = Foo { .Bar = x, .Baz = u8 }; \\} , "tmp.zig:7:30: error: unable to evaluate constant expression", ); cases.add( "runtime assignment to comptime union type", \\const Foo = union { \\ Bar: u8, \\ Baz: type, \\}; \\export fn f() void { \\ var x: u8 = 0; \\ const foo = Foo { .Bar = x }; \\} , "tmp.zig:7:30: error: unable to evaluate constant expression", ); cases.addTest( "nested vectors", \\export fn entry() void { \\ const V = @Vector(4, @Vector(4, u8)); \\ var v: V = undefined; \\} , "tmp.zig:2:26: error: vector element type must be integer, float, or pointer; '@Vector(4, u8)' is invalid", ); cases.add("compileLog of tagged enum doesn't crash the compiler", \\const Bar = union(enum(u32)) { \\ X: i32 = 1 \\}; \\ \\fn testCompileLog(x: Bar) void { \\ @compileLog(x); \\} \\ \\pub fn main () void { \\ comptime testCompileLog(Bar{.X = 123}); \\} , "tmp.zig:6:5: error: found compile log statement"); }