Undefined Behavior

Undefined Behavior

Zig has many instances of undefined behavior. If undefined behavior is detected at compile-time, Zig emits a compile error and refuses to continue. Most undefined behavior that cannot be detected at compile-time can be detected at runtime. In these cases, Zig has safety checks. Safety checks can be disabled on a per-block basis with @setRuntimeSafety. The ReleaseFast and ReleaseSmall build modes disable all safety checks (except where overridden by @setRuntimeSafety) in order to facilitate optimizations.

When a safety check fails, Zig crashes with a stack trace, like this:

test.zig

test "safety check" {
    unreachable;
}

$ zig test test.zig
Test [1/1] test "safety check"... 
thread 24774 panic: reached unreachable code
/home/andy/Downloads/zig/docgen_tmp/test.zig:2:5: 0x2067aa in test "safety check" (test)
    unreachable;
    ^
/home/andy/Downloads/zig/lib/std/special/test_runner.zig:76:28: 0x22d44a in std.special.main (test)
        } else test_fn.func();
                           ^
/home/andy/Downloads/zig/lib/std/start.zig:458:37: 0x225a2a in std.start.callMain (test)
            const result = root.main() catch |err| {
                                    ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20951e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x208525 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x208282 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
error: the following test command crashed:
docgen_tmp/zig-cache/o/838077344bc971dfe73a08c5661e78d1/test /home/andy/Downloads/zig/build/zig

Reaching Unreachable Code

At compile-time:

test.zig

comptime {
    assert(false);
}
fn assert(ok: bool) void {
    if (!ok) unreachable; // assertion failure
}

$ zig test test.zig
./docgen_tmp/test.zig:5:14: error: reached unreachable code
    if (!ok) unreachable; // assertion failure
             ^
./docgen_tmp/test.zig:2:11: note: called from here
    assert(false);
          ^
./docgen_tmp/test.zig:1:10: note: called from here
comptime {
         ^
./docgen_tmp/test.zig:2:11: note: referenced here
    assert(false);
          ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    std.debug.assert(false);
}

$ zig build-exe test.zig
$ ./test
thread 24948 panic: reached unreachable code
/home/andy/Downloads/zig/lib/std/debug.zig:226:14: 0x20432b in std.debug.assert (test)
    if (!ok) unreachable; // assertion failure
             ^
/home/andy/Downloads/zig/docgen_tmp/test.zig:4:21: 0x22a34a in main (test)
    std.debug.assert(false);
                    ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x2227cc in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x2062ce in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x2052d5 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205032 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Index out of Bounds

At compile-time:

test.zig

comptime {
    const array: [5]u8 = "hello".*;
    const garbage = array[5];
}

$ zig test test.zig
./docgen_tmp/test.zig:3:26: error: index 5 outside array of size 5
    const garbage = array[5];
                         ^

At runtime:

test.zig

pub fn main() void {
    var x = foo("hello");
}
fn foo(x: []const u8) u8 {
    return x[5];
}

$ zig build-exe test.zig
$ ./test
thread 25118 panic: index out of bounds
/home/andy/Downloads/zig/docgen_tmp/test.zig:6:13: 0x231089 in foo (test)
    return x[5];
            ^
/home/andy/Downloads/zig/docgen_tmp/test.zig:2:16: 0x22a386 in main (test)
    var x = foo("hello");
               ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x2227fc in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x2062fe in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205305 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205062 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Cast Negative Number to Unsigned Integer

At compile-time:

test.zig

comptime {
    const value: i32 = -1;
    const unsigned = @intCast(u32, value);
}

$ zig test test.zig
./docgen_tmp/test.zig:3:22: error: attempt to cast negative value to unsigned integer
    const unsigned = @intCast(u32, value);
                     ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var value: i32 = -1;
    var unsigned = @intCast(u32, value);
    std.debug.print("value: {}\n", .{unsigned});
}

$ zig build-exe test.zig
$ ./test
thread 25331 panic: attempt to cast negative value to unsigned integer
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:20: 0x22a3d7 in main (test)
    var unsigned = @intCast(u32, value);
                   ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22281c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20631e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205325 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205082 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

To obtain the maximum value of an unsigned integer, use std.math.maxInt.

Cast Truncates Data

At compile-time:

test.zig

comptime {
    const spartan_count: u16 = 300;
    const byte = @intCast(u8, spartan_count);
}

$ zig test test.zig
./docgen_tmp/test.zig:3:18: error: cast from 'u16' to 'u8' truncates bits
    const byte = @intCast(u8, spartan_count);
                 ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var spartan_count: u16 = 300;
    const byte = @intCast(u8, spartan_count);
    std.debug.print("value: {}\n", .{byte});
}

$ zig build-exe test.zig
$ ./test
thread 25617 panic: integer cast truncated bits
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:18: 0x22a3dc in main (test)
    const byte = @intCast(u8, spartan_count);
                 ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22281c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20631e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205325 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205082 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

To truncate bits, use @truncate.

Integer Overflow

Default Operations

The following operators can cause integer overflow:

+ (addition)
- (subtraction)
- (negation)
* (multiplication)
/ (division)
@divTrunc (division)
@divFloor (division)
@divExact (division)

Example with addition at compile-time:

test.zig

comptime {
    var byte: u8 = 255;
    byte += 1;
}

$ zig test test.zig
./docgen_tmp/test.zig:3:10: error: operation caused overflow
    byte += 1;
         ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var byte: u8 = 255;
    byte += 1;
    std.debug.print("value: {}\n", .{byte});
}

$ zig build-exe test.zig
$ ./test
thread 25792 panic: integer overflow
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:10: 0x22a3bf in main (test)
    byte += 1;
         ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22281c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20631e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205325 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205082 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Standard Library Math Functions

These functions provided by the standard library return possible errors.

@import("std").math.add
@import("std").math.sub
@import("std").math.mul
@import("std").math.divTrunc
@import("std").math.divFloor
@import("std").math.divExact
@import("std").math.shl

Example of catching an overflow for addition:

test.zig

const math = @import("std").math;
const print = @import("std").debug.print;
pub fn main() !void {
    var byte: u8 = 255;
    byte = if (math.add(u8, byte, 1)) |result| result else |err| {
        print("unable to add one: {s}\n", .{@errorName(err)});
        return err;
    };
    print("result: {}\n", .{byte});
}

$ zig build-exe test.zig
$ ./test
unable to add one: Overflow
error: Overflow
/home/andy/Downloads/zig/lib/std/math.zig:449:5: 0x23149b in std.math.add (test)
    return if (@addWithOverflow(T, a, b, &answer)) error.Overflow else answer;
    ^
/home/andy/Downloads/zig/docgen_tmp/test.zig:8:9: 0x22a6a4 in main (test)
        return err;
        ^

Builtin Overflow Functions

These builtins return a bool of whether or not overflow occurred, as well as returning the overflowed bits:

@addWithOverflow
@subWithOverflow
@mulWithOverflow
@shlWithOverflow

Example of @addWithOverflow:

test.zig

const print = @import("std").debug.print;
pub fn main() void {
    var byte: u8 = 255;
    var result: u8 = undefined;
    if (@addWithOverflow(u8, byte, 10, &result)) {
        print("overflowed result: {}\n", .{result});
    } else {
        print("result: {}\n", .{result});
    }
}

$ zig build-exe test.zig
$ ./test
overflowed result: 9

Wrapping Operations

These operations have guaranteed wraparound semantics.

+% (wraparound addition)
-% (wraparound subtraction)
-% (wraparound negation)
*% (wraparound multiplication)

test.zig

const std = @import("std");
const expect = std.testing.expect;
const minInt = std.math.minInt;
const maxInt = std.math.maxInt;
test "wraparound addition and subtraction" {
    const x: i32 = maxInt(i32);
    const min_val = x +% 1;
    try expect(min_val == minInt(i32));
    const max_val = min_val -% 1;
    try expect(max_val == maxInt(i32));
}

$ zig test test.zig
Test [1/1] test "wraparound addition and subtraction"... 
All 1 tests passed.

Exact Left Shift Overflow

At compile-time:

test.zig

comptime {
    const x = @shlExact(@as(u8, 0b01010101), 2);
}

$ zig test test.zig
./docgen_tmp/test.zig:2:15: error: operation caused overflow
    const x = @shlExact(@as(u8, 0b01010101), 2);
              ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var x: u8 = 0b01010101;
    var y = @shlExact(x, 2);
    std.debug.print("value: {}\n", .{y});
}

$ zig build-exe test.zig
$ ./test
thread 26395 panic: left shift overflowed bits
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:13: 0x22a41b in main (test)
    var y = @shlExact(x, 2);
            ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22285c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20635e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205365 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x2050c2 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Exact Right Shift Overflow

At compile-time:

test.zig

comptime {
    const x = @shrExact(@as(u8, 0b10101010), 2);
}

$ zig test test.zig
./docgen_tmp/test.zig:2:15: error: exact shift shifted out 1 bits
    const x = @shrExact(@as(u8, 0b10101010), 2);
              ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var x: u8 = 0b10101010;
    var y = @shrExact(x, 2);
    std.debug.print("value: {}\n", .{y});
}

$ zig build-exe test.zig
$ ./test
thread 26621 panic: right shift overflowed bits
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:13: 0x22a41b in main (test)
    var y = @shrExact(x, 2);
            ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22285c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20635e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205365 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x2050c2 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Division by Zero

At compile-time:

test.zig

comptime {
    const a: i32 = 1;
    const b: i32 = 0;
    const c = a / b;
}

$ zig test test.zig
./docgen_tmp/test.zig:4:17: error: division by zero
    const c = a / b;
                ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var a: u32 = 1;
    var b: u32 = 0;
    var c = a / b;
    std.debug.print("value: {}\n", .{c});
}

$ zig build-exe test.zig
$ ./test
thread 27029 panic: division by zero
/home/andy/Downloads/zig/docgen_tmp/test.zig:6:15: 0x22a3c9 in main (test)
    var c = a / b;
              ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22281c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20631e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205325 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205082 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Remainder Division by Zero

At compile-time:

test.zig

comptime {
    const a: i32 = 10;
    const b: i32 = 0;
    const c = a % b;
}

$ zig test test.zig
./docgen_tmp/test.zig:4:17: error: division by zero
    const c = a % b;
                ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var a: u32 = 10;
    var b: u32 = 0;
    var c = a % b;
    std.debug.print("value: {}\n", .{c});
}

$ zig build-exe test.zig
$ ./test
thread 27272 panic: remainder division by zero or negative value
/home/andy/Downloads/zig/docgen_tmp/test.zig:6:15: 0x22a3eb in main (test)
    var c = a % b;
              ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22281c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20631e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205325 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205082 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Exact Division Remainder

At compile-time:

test.zig

comptime {
    const a: u32 = 10;
    const b: u32 = 3;
    const c = @divExact(a, b);
}

$ zig test test.zig
./docgen_tmp/test.zig:4:15: error: exact division had a remainder
    const c = @divExact(a, b);
              ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var a: u32 = 10;
    var b: u32 = 3;
    var c = @divExact(a, b);
    std.debug.print("value: {}\n", .{c});
}

$ zig build-exe test.zig
$ ./test
thread 27557 panic: exact division produced remainder
/home/andy/Downloads/zig/docgen_tmp/test.zig:6:13: 0x22a40d in main (test)
    var c = @divExact(a, b);
            ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22281c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20631e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205325 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205082 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Attempt to Unwrap Null

At compile-time:

test.zig

comptime {
    const optional_number: ?i32 = null;
    const number = optional_number.?;
}

$ zig test test.zig
./docgen_tmp/test.zig:3:35: error: unable to unwrap null
    const number = optional_number.?;
                                  ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var optional_number: ?i32 = null;
    var number = optional_number.?;
    std.debug.print("value: {}\n", .{number});
}

$ zig build-exe test.zig
$ ./test
thread 27840 panic: attempt to use null value
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:33: 0x22a3cc in main (test)
    var number = optional_number.?;
                                ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22282c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20632e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205335 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205092 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

One way to avoid this crash is to test for null instead of assuming non-null, with the if expression:

test.zig

const print = @import("std").debug.print;
pub fn main() void {
    const optional_number: ?i32 = null;
    if (optional_number) |number| {
        print("got number: {}\n", .{number});
    } else {
        print("it's null\n", .{});
    }
}

$ zig build-exe test.zig
$ ./test
it's null

Attempt to Unwrap Error

At compile-time:

test.zig

comptime {
    const number = getNumberOrFail() catch unreachable;
}
fn getNumberOrFail() !i32 {
    return error.UnableToReturnNumber;
}

$ zig test test.zig
./docgen_tmp/test.zig:2:38: error: caught unexpected error 'UnableToReturnNumber'
    const number = getNumberOrFail() catch unreachable;
                                     ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    const number = getNumberOrFail() catch unreachable;
    std.debug.print("value: {}\n", .{number});
}
fn getNumberOrFail() !i32 {
    return error.UnableToReturnNumber;
}

$ zig build-exe test.zig
$ ./test
thread 28265 panic: attempt to unwrap error: UnableToReturnNumber
/home/andy/Downloads/zig/docgen_tmp/test.zig:9:5: 0x231144 in getNumberOrFail (test)
    return error.UnableToReturnNumber;
    ^
???:?:?: 0x20cb92 in ??? (???)
/home/andy/Downloads/zig/docgen_tmp/test.zig:4:38: 0x22a41b in main (test)
    const number = getNumberOrFail() catch unreachable;
                                     ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22283c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20633e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205345 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x2050a2 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

One way to avoid this crash is to test for an error instead of assuming a successful result, with the if expression:

test.zig

const print = @import("std").debug.print;
pub fn main() void {
    const result = getNumberOrFail();
    if (result) |number| {
        print("got number: {}\n", .{number});
    } else |err| {
        print("got error: {s}\n", .{@errorName(err)});
    }
}
fn getNumberOrFail() !i32 {
    return error.UnableToReturnNumber;
}

$ zig build-exe test.zig
$ ./test
got error: UnableToReturnNumber

Invalid Error Code

At compile-time:

test.zig

comptime {
    const err = error.AnError;
    const number = @errorToInt(err) + 10;
    const invalid_err = @intToError(number);
}

$ zig test test.zig
./docgen_tmp/test.zig:4:25: error: integer value 11 represents no error
    const invalid_err = @intToError(number);
                        ^

At runtime:

test.zig

const std = @import("std");
pub fn main() void {
    var err = error.AnError;
    var number = @errorToInt(err) + 500;
    var invalid_err = @intToError(number);
    std.debug.print("value: {}\n", .{number});
}

$ zig build-exe test.zig
$ ./test
thread 28730 panic: invalid error code
/home/andy/Downloads/zig/docgen_tmp/test.zig:6:23: 0x22a423 in main (test)
    var invalid_err = @intToError(number);
                      ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22284c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20634e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205355 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x2050b2 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Invalid Enum Cast

At compile-time:

test.zig

const Foo = enum {
    a,
    b,
    c,
};
comptime {
    const a: u2 = 3;
    const b = @intToEnum(Foo, a);
}

$ zig test test.zig
./docgen_tmp/test.zig:8:15: error: enum 'Foo' has no tag matching integer value 3
    const b = @intToEnum(Foo, a);
              ^
./docgen_tmp/test.zig:1:13: note: 'Foo' declared here
const Foo = enum {
            ^

At runtime:

test.zig

const std = @import("std");
const Foo = enum {
    a,
    b,
    c,
};
pub fn main() void {
    var a: u2 = 3;
    var b = @intToEnum(Foo, a);
    std.debug.print("value: {s}\n", .{@tagName(b)});
}

$ zig build-exe test.zig
$ ./test
thread 28973 panic: invalid enum value
/home/andy/Downloads/zig/docgen_tmp/test.zig:11:13: 0x22a479 in main (test)
    var b = @intToEnum(Foo, a);
            ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x2228cc in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x2063ce in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x2053d5 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205132 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Invalid Error Set Cast

At compile-time:

test.zig

const Set1 = error{
    A,
    B,
};
const Set2 = error{
    A,
    C,
};
comptime {
    _ = @errSetCast(Set2, Set1.B);
}

$ zig test test.zig
./docgen_tmp/test.zig:10:9: error: error.B not a member of error set 'Set2'
    _ = @errSetCast(Set2, Set1.B);
        ^

At runtime:

test.zig

const std = @import("std");
const Set1 = error{
    A,
    B,
};
const Set2 = error{
    A,
    C,
};
pub fn main() void {
    foo(Set1.B);
}
fn foo(set1: Set1) void {
    const x = @errSetCast(Set2, set1);
    std.debug.print("value: {}\n", .{x});
}

$ zig build-exe test.zig
$ ./test
thread 29255 panic: invalid error code
/home/andy/Downloads/zig/docgen_tmp/test.zig:15:15: 0x231146 in foo (test)
    const x = @errSetCast(Set2, set1);
              ^
/home/andy/Downloads/zig/docgen_tmp/test.zig:12:8: 0x22a41d in main (test)
    foo(Set1.B);
       ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x22289c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20639e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x2053a5 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205102 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Incorrect Pointer Alignment

At compile-time:

test.zig

comptime {
    const ptr = @intToPtr(*align(1) i32, 0x1);
    const aligned = @alignCast(4, ptr);
}

$ zig test test.zig
./docgen_tmp/test.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes
    const aligned = @alignCast(4, ptr);
                                  ^
./docgen_tmp/test.zig:3:21: note: referenced here
    const aligned = @alignCast(4, ptr);
                    ^

At runtime:

test.zig

const mem = @import("std").mem;
pub fn main() !void {
    var array align(4) = [_]u32{ 0x11111111, 0x11111111 };
    const bytes = mem.sliceAsBytes(array[0..]);
    if (foo(bytes) != 0x11111111) return error.Wrong;
}
fn foo(bytes: []u8) u32 {
    const slice4 = bytes[1..5];
    const int_slice = mem.bytesAsSlice(u32, @alignCast(4, slice4));
    return int_slice[0];
}

$ zig build-exe test.zig
$ ./test
thread 29498 panic: incorrect alignment
/home/andy/Downloads/zig/docgen_tmp/test.zig:9:59: 0x2313cc in foo (test)
    const int_slice = mem.bytesAsSlice(u32, @alignCast(4, slice4));
                                                          ^
/home/andy/Downloads/zig/docgen_tmp/test.zig:5:12: 0x22a595 in main (test)
    if (foo(bytes) != 0x11111111) return error.Wrong;
           ^
/home/andy/Downloads/zig/lib/std/start.zig:458:37: 0x2228ba in std.start.callMain (test)
            const result = root.main() catch |err| {
                                    ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x20638e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x205395 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x2050f2 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

Wrong Union Field Access

At compile-time:

test.zig

comptime {
    var f = Foo{ .int = 42 };
    f.float = 12.34;
}
const Foo = union {
    float: f32,
    int: u32,
};

$ zig test test.zig
./docgen_tmp/test.zig:3:6: error: accessing union field 'float' while field 'int' is set
    f.float = 12.34;
     ^

At runtime:

test.zig

const std = @import("std");
const Foo = union {
    float: f32,
    int: u32,
};
pub fn main() void {
    var f = Foo{ .int = 42 };
    bar(&f);
}
fn bar(f: *Foo) void {
    f.float = 12.34;
    std.debug.print("value: {}\n", .{f.float});
}

$ zig build-exe test.zig
$ ./test
thread 29740 panic: access of inactive union field
/home/andy/Downloads/zig/docgen_tmp/test.zig:14:6: 0x23e8ea in bar (test)
    f.float = 12.34;
     ^
/home/andy/Downloads/zig/docgen_tmp/test.zig:10:8: 0x237bbc in main (test)
    bar(&f);
       ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x23002c in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x213b2e in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x212b35 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x212892 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)

This safety is not available for extern or packed unions.

To change the active field of a union, assign the entire union, like this:

test.zig

const std = @import("std");
const Foo = union {
    float: f32,
    int: u32,
};
pub fn main() void {
    var f = Foo{ .int = 42 };
    bar(&f);
}
fn bar(f: *Foo) void {
    f.* = Foo{ .float = 12.34 };
    std.debug.print("value: {}\n", .{f.float});
}

$ zig build-exe test.zig
$ ./test
value: 1.23400001e+01

To change the active field of a union when a meaningful value for the field is not known, use undefined, like this:

test.zig

const std = @import("std");
const Foo = union {
    float: f32,
    int: u32,
};
pub fn main() void {
    var f = Foo{ .int = 42 };
    f = Foo{ .float = undefined };
    bar(&f);
    std.debug.print("value: {}\n", .{f.float});
}
fn bar(f: *Foo) void {
    f.float = 12.34;
}

$ zig build-exe test.zig
$ ./test
value: 1.23400001e+01

Out of Bounds Float to Integer Cast

TODO

Pointer Cast Invalid Null

This happens when casting a pointer with the address 0 to a pointer which may not have the address 0. For example, C Pointers, Optional Pointers, and allowzero pointers allow address zero, but normal Pointers do not.

At compile-time:

test.zig

comptime {
    const opt_ptr: ?*i32 = null;
    const ptr = @ptrCast(*i32, opt_ptr);
}

$ zig test test.zig
./docgen_tmp/test.zig:3:17: error: null pointer casted to type '*i32'
    const ptr = @ptrCast(*i32, opt_ptr);
                ^

At runtime:

test.zig

pub fn main() void {
    var opt_ptr: ?*i32 = null;
    var ptr = @ptrCast(*i32, opt_ptr);
}

$ zig build-exe test.zig
$ ./test
thread 30183 panic: cast causes pointer to be null
/home/andy/Downloads/zig/docgen_tmp/test.zig:3:15: 0x22a370 in main (test)
    var ptr = @ptrCast(*i32, opt_ptr);
              ^
/home/andy/Downloads/zig/lib/std/start.zig:448:22: 0x2227cc in std.start.callMain (test)
            root.main();
                     ^
/home/andy/Downloads/zig/lib/std/start.zig:400:12: 0x2062ce in std.start.callMainWithArgs (test)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/andy/Downloads/zig/lib/std/start.zig:319:17: 0x2052d5 in std.start.posixCallMainAndExit (test)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/andy/Downloads/zig/lib/std/start.zig:244:5: 0x205032 in std.start._start (test)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
(process terminated by signal)