get examples working

crates/cli/tests/cli_run.rs

@@ -702,7 +702,7 @@ mod cli_run {
                 Arg::PlainText("81"),
             ],
             &[],
-            "4.000000000000001\n",
+            "4\n",
             UseValgrind::No,
             TestCliCommands::Run,
         )

crates/cli/tests/fixtures/multi-dep-str/platform/host.zig

@@ -26,12 +26,12 @@ export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
 export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque {
     _ = old_size;
     _ = alignment;
-    return realloc(@alignCast(16, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
-    free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void {
@@ -42,7 +42,7 @@ export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -92,7 +92,7 @@ pub export fn main() i32 {
     roc__mainForHost_1_exposed_generic(&callresult);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     // stdout the result
     stdout.print("{s}\n", .{callresult.asSlice()}) catch unreachable;
@@ -105,5 +105,5 @@ pub export fn main() i32 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }

crates/cli/tests/fixtures/multi-dep-thunk/platform/host.zig

@@ -11,6 +11,7 @@ const Allocator = mem.Allocator;
 
 extern fn roc__mainForHost_1_exposed_generic(*RocStr) void;
 
+const Align = 2 * @alignOf(usize);
 extern fn malloc(size: usize) callconv(.C) ?*anyopaque;
 extern fn realloc(c_ptr: [*]align(@alignOf(u128)) u8, size: usize) callconv(.C) ?*anyopaque;
 extern fn free(c_ptr: [*]align(@alignOf(u128)) u8) callconv(.C) void;
@@ -25,12 +26,12 @@ export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
 export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque {
     _ = old_size;
     _ = alignment;
-    return realloc(@alignCast(16, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
-    free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void {
@@ -41,7 +42,7 @@ export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -91,7 +92,7 @@ pub export fn main() i32 {
     roc__mainForHost_1_exposed_generic(&callresult);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     // stdout the result
     stdout.print("{s}\n", .{callresult.asSlice()}) catch unreachable;
@@ -104,5 +105,5 @@ pub export fn main() i32 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }

crates/cli/tests/fixtures/packages/platform/host.zig

@@ -26,12 +26,12 @@ export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
 export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque {
     _ = old_size;
     _ = alignment;
-    return realloc(@alignCast(16, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
-    free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void {
@@ -42,7 +42,7 @@ export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -92,7 +92,7 @@ pub export fn main() i32 {
     roc__mainForHost_1_exposed_generic(&callresult);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     // stdout the result
     stdout.print("{s}\n", .{callresult.asSlice()}) catch unreachable;
@@ -105,5 +105,5 @@ pub export fn main() i32 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }

crates/cli_testing_examples/algorithms/fibonacci-platform/host.zig

@@ -38,7 +38,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -47,14 +47,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -103,7 +103,7 @@ pub export fn main() u8 {
     const result = roc__mainForHost_1_exposed(10);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     stdout.print("{d}\n", .{result}) catch unreachable;
 
@@ -114,5 +114,5 @@ pub export fn main() u8 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }

crates/cli_testing_examples/algorithms/quicksort-platform/host.zig

@@ -37,7 +37,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -46,14 +46,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -111,8 +111,8 @@ pub export fn main() u8 {
 
     var numbers = raw_numbers[1..];
 
-    for (numbers) |_, i| {
-        numbers[i] = @mod(@intCast(i64, i), 12);
+    for (numbers, 0..) |_, i| {
+        numbers[i] = @mod(@as(i64, @intCast(i)), 12);
     }
 
     var roc_list = RocList{ .elements = numbers, .length = NUM_NUMS, .capacity = NUM_NUMS };
@@ -123,13 +123,13 @@ pub export fn main() u8 {
     const callresult: RocList = roc__mainForHost_1_exposed(roc_list);
 
     // stdout the result
-    const length = std.math.min(20, callresult.length);
+    const length = @min(20, callresult.length);
     var result = callresult.elements[0..length];
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
-    for (result) |x, i| {
+    for (result, 0..) |x, i| {
         if (i == 0) {
             stdout.print("[{}, ", .{x}) catch unreachable;
         } else if (i == length - 1) {
@@ -146,5 +146,5 @@ pub export fn main() u8 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }

crates/cli_testing_examples/benchmarks/platform/host.zig

@@ -42,7 +42,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -51,14 +51,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -105,9 +105,9 @@ pub fn main() !u8 {
     const stderr = std.io.getStdErr().writer();
 
     // The size might be zero; if so, make it at least 8 so that we don't have a nullptr
-    const size = std.math.max(@intCast(usize, roc__mainForHost_1_exposed_size()), 8);
-    const raw_output = roc_alloc(@intCast(usize, size), @alignOf(u64)).?;
-    var output = @ptrCast([*]u8, raw_output);
+    const size = @max(@as(usize, @intCast(roc__mainForHost_1_exposed_size())), 8);
+    const raw_output = roc_alloc(@as(usize, @intCast(size)), @alignOf(u64)).?;
+    var output = @as([*]u8, @ptrCast(raw_output));
 
     defer {
         roc_dealloc(raw_output, @alignOf(u64));
@@ -117,12 +117,12 @@ pub fn main() !u8 {
 
     roc__mainForHost_1_exposed_generic(output);
 
-    const closure_data_pointer = @ptrCast([*]u8, output);
+    const closure_data_pointer = @as([*]u8, @ptrCast(output));
 
     call_the_closure(closure_data_pointer);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     stderr.print("runtime: {d:.3}ms\n", .{seconds * 1000}) catch unreachable;
 
@@ -130,16 +130,16 @@ pub fn main() !u8 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }
 
 fn call_the_closure(closure_data_pointer: [*]u8) void {
     const allocator = std.heap.page_allocator;
 
     // The size might be zero; if so, make it at least 8 so that we don't have a nullptr
-    const size = std.math.max(roc__mainForHost_0_result_size(), 8);
-    const raw_output = allocator.allocAdvanced(u8, @alignOf(u64), @intCast(usize, size), .at_least) catch unreachable;
-    var output = @ptrCast([*]u8, raw_output);
+    const size = @max(roc__mainForHost_0_result_size(), 8);
+    const raw_output = allocator.alignedAlloc(u8, @alignOf(u64), @as(usize, @intCast(size))) catch unreachable;
+    var output = @as([*]u8, @ptrCast(raw_output));
 
     defer {
         allocator.free(raw_output);
@@ -227,7 +227,7 @@ fn roc_fx_getInt_help() !i64 {
 
     // make sure to strip `\r` on windows
     const raw_line: []u8 = (try stdin.readUntilDelimiterOrEof(&buf, '\n')) orelse "";
-    const line = std.mem.trimRight(u8, raw_line, &std.ascii.spaces);
+    const line = std.mem.trimRight(u8, raw_line, &std.ascii.whitespace);
 
     return std.fmt.parseInt(i64, line, 10);
 }

crates/cli_testing_examples/expects/zig-platform/host.zig

@@ -32,7 +32,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -41,14 +41,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -111,7 +111,7 @@ pub fn main() u8 {
     roc__mainForHost_1_exposed_generic(&callresult);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     // stdout the result
     stdout.print("{s}", .{callresult.asSlice()}) catch unreachable;

crates/compiler/build/src/link.rs

@@ -163,10 +163,10 @@ pub fn build_zig_host_native(
     zig_cmd.args([
         zig_host_src,
         &format!("-femit-bin={emit_bin}"),
-        "--pkg-begin",
+        "--mod",
+        &format!("glue::{}", find_zig_glue_path().to_str().unwrap()),
+        "--deps",
         "glue",
-        find_zig_glue_path().to_str().unwrap(),
-        "--pkg-end",
         // include libc
         "-lc",
         // cross-compile?
@@ -235,10 +235,10 @@ pub fn build_zig_host_native(
     zig_cmd.args(&[
         zig_host_src,
         &format!("-femit-bin={}", emit_bin),
-        "--pkg-begin",
+        "--mod",
+        &format!("glue::{}", find_zig_glue_path().to_str().unwrap()),
+        "--deps",
         "glue",
-        find_zig_glue_path().to_str().unwrap(),
-        "--pkg-end",
         // include the zig runtime
         // "-fcompiler-rt", compiler-rt causes segfaults on windows; investigate why
         // include libc
@@ -282,10 +282,10 @@ pub fn build_zig_host_wasm32(
             "build-obj",
             zig_host_src,
             emit_bin,
-            "--pkg-begin",
+            "--mod",
+            &format!("glue::{}", find_zig_glue_path().to_str().unwrap()),
+            "--deps",
             "glue",
-            find_zig_glue_path().to_str().unwrap(),
-            "--pkg-end",
             // include the zig runtime
             // "-fcompiler-rt",
             // include libc
@@ -1184,7 +1184,7 @@ fn get_macos_version() -> String {
     full_version_string
         .trim_end()
         .split('.')
-        .take(2)
+        .take(3)
         .collect::<Vec<&str>>()
         .join(".")
 }
@@ -1208,10 +1208,10 @@ fn link_wasm32(
             &format!("-femit-bin={}", output_path.to_str().unwrap()),
             "-target",
             "wasm32-wasi-musl",
-            "--pkg-begin",
+            "--mod",
+            &format!("glue::{}", find_zig_glue_path().to_str().unwrap()),
+            "--deps",
             "glue",
-            find_zig_glue_path().to_str().unwrap(),
-            "--pkg-end",
             "--strip",
             "-O",
             "ReleaseSmall",
@@ -1239,10 +1239,10 @@ fn link_windows(
                     &format!("-femit-bin={}", output_path.to_str().unwrap()),
                     "-target",
                     "native",
-                    "--pkg-begin",
+                    "--mod",
+                    &format!("glue::{}", find_zig_glue_path().to_str().unwrap()),
+                    "--deps",
                     "glue",
-                    find_zig_glue_path().to_str().unwrap(),
-                    "--pkg-end",
                     "--strip",
                     "-O",
                     "Debug",

crates/compiler/build/src/target.rs

@@ -87,12 +87,12 @@ pub fn target_zig_str(target: &Triple) -> &'static str {
             architecture: Architecture::X86_64,
             operating_system: OperatingSystem::Darwin,
             ..
-        } => "x86_64-macos-gnu",
+        } => "x86_64-macos-none",
         Triple {
             architecture: Architecture::Aarch64(_),
             operating_system: OperatingSystem::Darwin,
             ..
-        } => "aarch64-macos-gnu",
+        } => "aarch64-macos-none",
         _ => internal_error!("TODO gracefully handle unsupported target: {:?}", target),
     }
 }

crates/valgrind/zig-platform/host.zig

@@ -32,7 +32,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -41,14 +41,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -107,7 +107,7 @@ pub fn main() u8 {
     roc__mainForHost_1_exposed_generic(&callresult);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     // stdout the result
     stdout.print("{s}", .{callresult.asSlice()}) catch unreachable;

examples/cli/effects-platform/host.zig

@@ -46,7 +46,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -55,14 +55,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -105,9 +105,9 @@ pub export fn main() u8 {
     const stderr = std.io.getStdErr().writer();
 
     // NOTE the return size can be zero, which will segfault. Always allocate at least 8 bytes
-    const size = std.math.max(8, @intCast(usize, roc__mainForHost_1_exposed_size()));
-    const raw_output = allocator.allocAdvanced(u8, @alignOf(u64), @intCast(usize, size), .at_least) catch unreachable;
-    var output = @ptrCast([*]u8, raw_output);
+    const size = @max(8, @as(usize, @intCast(roc__mainForHost_1_exposed_size())));
+    const raw_output = allocator.alignedAlloc(u8, @alignOf(u64), @as(usize, @intCast(size))) catch unreachable;
+    var output = @as([*]u8, @ptrCast(raw_output));
 
     defer {
         allocator.free(raw_output);
@@ -120,7 +120,7 @@ pub export fn main() u8 {
     call_the_closure(output);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     stderr.print("runtime: {d:.3}ms\n", .{seconds * 1000}) catch unreachable;
 
@@ -128,7 +128,7 @@ pub export fn main() u8 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }
 
 fn call_the_closure(closure_data_pointer: [*]u8) void {
@@ -147,8 +147,8 @@ fn call_the_closure(closure_data_pointer: [*]u8) void {
         return;
     }
 
-    const raw_output = allocator.allocAdvanced(u8, @alignOf(u64), @intCast(usize, size), .at_least) catch unreachable;
-    var output = @ptrCast([*]u8, raw_output);
+    const raw_output = allocator.alignedAlloc(u8, @alignOf(u64), @as(usize, @intCast(size))) catch unreachable;
+    var output = @as([*]u8, @ptrCast(raw_output));
 
     defer {
         allocator.free(raw_output);
@@ -170,7 +170,7 @@ fn roc_fx_getLine_help() !RocStr {
 
     const line: []u8 = (try stdin.readUntilDelimiterOrEof(&buf, '\n')) orelse "";
 
-    return str.RocStr.init(@ptrCast([*]const u8, line), line.len);
+    return str.RocStr.init(@as([*]const u8, @ptrCast(line)), line.len);
 }
 
 pub export fn roc_fx_putLine(rocPath: *str.RocStr) i64 {
@@ -213,7 +213,7 @@ fn roc_fx_getInt_help() !i64 {
 
     // make sure to strip `\r` on windows
     const raw_line: []u8 = (try stdin.readUntilDelimiterOrEof(&buf, '\n')) orelse "";
-    const line = std.mem.trimRight(u8, raw_line, &std.ascii.spaces);
+    const line = std.mem.trimRight(u8, raw_line, &std.ascii.whitespace);
 
     return std.fmt.parseInt(i64, line, 10);
 }

examples/cli/tui-platform/host.zig

@@ -24,8 +24,8 @@ extern fn roc__mainForHost_0_result_size() i64;
 
 fn allocate_model(allocator: *Allocator) MutModel {
     const size = roc__mainForHost_0_result_size();
-    const raw_output = allocator.allocAdvanced(u8, @alignOf(u64), @intCast(usize, size), .at_least) catch unreachable;
-    var output = @ptrCast([*]u8, raw_output);
+    const raw_output = allocator.alignedAlloc(u8, @alignOf(u64), @as(usize, @intCast(size))) catch unreachable;
+    var output = @as([*]u8, @ptrCast(raw_output));
 
     return output;
 }
@@ -101,7 +101,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -110,14 +110,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -168,7 +168,7 @@ pub export fn main() callconv(.C) u8 {
     call_the_closure(program);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     const stderr = std.io.getStdErr().writer();
     stderr.print("runtime: {d:.3}ms\n", .{seconds * 1000}) catch unreachable;
@@ -177,7 +177,7 @@ pub export fn main() callconv(.C) u8 {
 }
 
 fn to_seconds(tms: std.os.timespec) f64 {
-    return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0);
+    return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
 }
 
 fn call_the_closure(program: Program) void {
@@ -280,7 +280,7 @@ fn roc_fx_getInt_help() !i64 {
 
     // make sure to strip `\r` on windows
     const raw_line: []u8 = (try stdin.readUntilDelimiterOrEof(&buf, '\n')) orelse "";
-    const line = std.mem.trimRight(u8, raw_line, &std.ascii.spaces);
+    const line = std.mem.trimRight(u8, raw_line, &std.ascii.whitespace);
 
     return std.fmt.parseInt(i64, line, 10);
 }

examples/nodejs-interop/wasm/platform/host.zig

@@ -24,13 +24,13 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
     _ = old_size;
     _ = alignment;
 
-    return realloc(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
 
-    free(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 // NOTE roc_panic is provided in the JS file, so it can throw an exception

examples/platform-switching/web-assembly-platform/host.zig

@@ -8,10 +8,10 @@ comptime {
     }
 }
 
-const Align = extern struct { a: usize, b: usize };
-extern fn malloc(size: usize) callconv(.C) ?*align(@alignOf(Align)) anyopaque;
-extern fn realloc(c_ptr: [*]align(@alignOf(Align)) u8, size: usize) callconv(.C) ?*anyopaque;
-extern fn free(c_ptr: [*]align(@alignOf(Align)) u8) callconv(.C) void;
+const Align = 2 * @alignOf(usize);
+extern fn malloc(size: usize) callconv(.C) ?*align(Align) anyopaque;
+extern fn realloc(c_ptr: [*]align(Align) u8, size: usize) callconv(.C) ?*anyopaque;
+extern fn free(c_ptr: [*]align(Align) u8) callconv(.C) void;
 extern fn memcpy(dest: *anyopaque, src: *anyopaque, count: usize) *anyopaque;
 
 export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
@@ -24,13 +24,13 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
     _ = old_size;
     _ = alignment;
 
-    return realloc(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
 
-    free(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 // NOTE roc_panic is provided in the JS file, so it can throw an exception

examples/platform-switching/zig-platform/host.zig

@@ -32,7 +32,7 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
         stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
     }
 
-    return realloc(@alignCast(Align, @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
@@ -41,14 +41,14 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
         stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
     }
 
-    free(@alignCast(Align, @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
 
     const stderr = std.io.getStdErr().writer();
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);
 }
@@ -107,7 +107,7 @@ pub fn main() u8 {
     roc__mainForHost_1_exposed_generic(&callresult);
 
     const nanos = timer.read();
-    const seconds = (@intToFloat(f64, nanos) / 1_000_000_000.0);
+    const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
 
     // stdout the result
     stdout.print("{s}", .{callresult.asSlice()}) catch unreachable;

examples/virtual-dom-wip/platform/src/client-side/host.zig

@@ -4,9 +4,9 @@ const builtin = @import("builtin");
 const RocStr = str.RocStr;
 
 const Align = extern struct { a: usize, b: usize };
-extern fn malloc(size: usize) callconv(.C) ?*align(@alignOf(Align)) anyopaque;
-extern fn realloc(c_ptr: [*]align(@alignOf(Align)) u8, size: usize) callconv(.C) ?*anyopaque;
-extern fn free(c_ptr: [*]align(@alignOf(Align)) u8) callconv(.C) void;
+extern fn malloc(size: usize) callconv(.C) ?*align(Align) anyopaque;
+extern fn realloc(c_ptr: [*]align(Align) u8, size: usize) callconv(.C) ?*anyopaque;
+extern fn free(c_ptr: [*]align(Align) u8) callconv(.C) void;
 extern fn memcpy(dest: *anyopaque, src: *anyopaque, count: usize) *anyopaque;
 
 export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
@@ -19,18 +19,18 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
     _ = old_size;
     _ = alignment;
 
-    return realloc(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
 
-    free(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(message: RocStr, tag_id: u32) callconv(.C) void {
     _ = tag_id;
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     const stderr = std.io.getStdErr().writer();
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);

examples/virtual-dom-wip/platform/src/server-side/host.zig

@@ -19,18 +19,18 @@ export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align
     _ = old_size;
     _ = alignment;
 
-    return realloc(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)), new_size);
+    return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
 }
 
 export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = alignment;
 
-    free(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)));
+    free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
 }
 
 export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = tag_id;
-    const msg = @ptrCast([*:0]const u8, c_ptr);
+    const msg = @as([*:0]const u8, @ptrCast(c_ptr));
     const stderr = std.io.getStdErr().writer();
     stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
     std.process.exit(0);