fix: ci build

Author: hanabi1224

.github/dart.sh

@@ -9,12 +9,12 @@ sudo ln -sf $PWD/dart-sdk/bin/dart /usr/local/bin/dart
 popd
 
 # dart3
-mkdir dart3sdk
-pushd dart3sdk
-wget https://storage.googleapis.com/dart-archive/channels/dev/release/latest/sdk/dartsdk-linux-x64-release.zip -O dartsdk.zip
-unzip -o dartsdk.zip
-sudo ln -sf $PWD/dart-sdk/bin/dart /usr/local/bin/dart3
-popd
-popd
-dart --version
-dart3 --version
+# mkdir dart3sdk
+# pushd dart3sdk
+# wget https://storage.googleapis.com/dart-archive/channels/dev/release/latest/sdk/dartsdk-linux-x64-release.zip -O dartsdk.zip
+# unzip -o dartsdk.zip
+# sudo ln -sf $PWD/dart-sdk/bin/dart /usr/local/bin/dart3
+# popd
+# popd
+# dart --version
+# dart3 --version

.github/odin.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/sh
 
-VERSION=dev-2023-04
+VERSION=dev-2023-07
 FILE_NAME=odin-ubuntu-amd64-$VERSION.zip
 sudo apt-get install -y aria2
 mkdir /tmp/odin

.github/workflows/bench.yml

@@ -1,10 +1,14 @@
 name: bench
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 on:
   push:
     branches: [main]
   pull_request:
     branches: [main]
   workflow_dispatch:
+  merge_group:
   schedule:
     - cron: "0 0 1 * *"
 env:

.github/workflows/cancel-stale.yml

@@ -1,11 +1,14 @@
 name: site
-
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 on:
   # push:
   #   branches: [main]
   pull_request:
     branches: [main]
   workflow_dispatch:
+  merge_group:
 jobs:
   build:
     runs-on: ${{ matrix.os }}

.github/workflows/site.yml

@@ -9,7 +9,7 @@ const global_allocator = std.heap.c_allocator;
 pub fn main() !void {
     const stdout = std.io.getStdOut().writer();
     const n = try get_n();
-    const max_depth = math.max(MIN_DEPTH + 2, n);
+    const max_depth = @max(MIN_DEPTH + 2, n);
     {
         const stretch_depth = max_depth + 1;
         const stretch_tree = Node.make(stretch_depth, global_allocator).?;
@@ -21,7 +21,7 @@ pub fn main() !void {
 
     var depth: usize = MIN_DEPTH;
     while (depth <= max_depth) : (depth += 2) {
-        const iterations = @intCast(usize, 1) << @intCast(u6, max_depth - depth + MIN_DEPTH);
+        const iterations = @as(usize, 1) << @as(u6, @intCast(max_depth - depth + MIN_DEPTH));
         var sum: usize = 0;
         var i: usize = 0;
         while (i < iterations) : (i += 1) {

bench/algorithm/binarytrees/1.zig

@@ -28,14 +28,14 @@ pub fn main() !void {
     defer a.deinit();
     var ten = try bigint.Managed.initSet(global_allocator, 10);
     defer ten.deinit();
-    try bigint.Managed.pow(&a, &ten, @bitCast(u32, n - 1));
+    try bigint.Managed.pow(&a, &ten, @as(u32, @bitCast(n - 1)));
     var tmp = try bigint.Managed.init(global_allocator);
     defer tmp.deinit();
     try bigint.Managed.mul(&tmp, &answer, &a);
     try bigint.Managed.divFloor(&answer, &a, &tmp, &q);
     var str = try answer.toString(global_allocator, 10, std.fmt.Case.lower);
     var i: usize = 0;
-    var n_usize = @as(usize, @bitCast(u32, n));
+    var n_usize = @as(usize, @as(u32, @bitCast(n)));
     while (i < n_usize) {
         var sb = [10:0]u8{ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
         var j: usize = i;
@@ -99,8 +99,8 @@ fn test_k(n: i32, k: i32) bool {
     if (k < 0) {
         return false;
     }
-    var float_k = @intToFloat(f64, k);
-    var float_n = @intToFloat(f64, n);
+    var float_k: f64 = @floatFromInt(k);
+    var float_n: f64 = @floatFromInt(n);
     var ln_k_factorial = float_k * (math.ln(float_k) - 1.0) + 0.5 * math.ln(math.tau);
     var log_10_k_factorial = ln_k_factorial / math.ln10;
     return log_10_k_factorial >= float_n + 50.0;

bench/algorithm/edigits/1.zig

@@ -51,11 +51,11 @@ pub fn main() !void {
                 flips_count += 1;
             }
 
-            max_flips_count = std.math.max(max_flips_count, flips_count);
+            max_flips_count = @max(max_flips_count, flips_count);
             if (perm_count % 2 == 0) {
-                checksum += @intCast(isize, flips_count);
+                checksum += @intCast(flips_count);
             } else {
-                checksum -= @intCast(isize, flips_count);
+                checksum -= @intCast(flips_count);
             }
 
             while (true) : (r += 1) {

bench/algorithm/fannkuch-redux/1.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 
 const max_n = 12;
-const Vec = std.meta.Vector(max_n, u8);
+const Vec = @Vector(max_n, u8);
 
 fn runInParallel(tasks: []std.Thread, len: usize, comptime f: anytype, args: anytype) !void {
     const len_per_task = @divTrunc(len, tasks.len + 1);
@@ -73,7 +73,7 @@ fn countAtPos(n: u8, start: usize) [max_n]u8 {
     while (i > 0) {
         i -= 1;
         const total_perms = factorialComptime(i);
-        count[i] = i + 1 - @intCast(u8, r / total_perms);
+        count[i] = i + 1 - @as(u8, @intCast(r / total_perms));
         r %= total_perms;
     }
     return count;
@@ -94,11 +94,11 @@ const Stats = struct {
 
 fn nextPermutation(perm: Vec, count: []u8) ?Vec {
     const r = for (count, 0..) |v, i| {
-        if (v != 1) break @intCast(u8, i);
+        if (v != 1) break @as(u8, @intCast(i));
     } else return null;
     const next_perm = applyMask(perm, r + 1, nextPermMask);
     count[r] -= 1;
-    for (count[0..r], 0..) |*v, i| v.* = @intCast(u8, i + 1);
+    for (count[0..r], 0..) |*v, i| v.* = @intCast(i + 1);
     return next_perm;
 }
 
@@ -109,9 +109,9 @@ fn pfannkuchenStats(first: usize, last: usize, n: u8, res: *Stats) void {
     var i = first;
     while (i < last) : (i += 1) {
         const flips = pfannkuchen(perm);
-        const parity = 1 - @intCast(i32, i % 2) * 2;
-        stats.max_flips = std.math.max(stats.max_flips, flips);
-        stats.checksum += @intCast(i32, flips) * parity;
+        const parity = 1 - @as(i32, @intCast(i % 2)) * 2;
+        stats.max_flips = @max(stats.max_flips, flips);
+        stats.checksum += @as(i32, @intCast(flips)) * parity;
         perm = nextPermutation(perm, count[0..n]) orelse break;
     }
     _ = @atomicRmw(u32, &res.max_flips, .Max, stats.max_flips, .SeqCst);

bench/algorithm/fannkuch-redux/2-m.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const Vec = std.meta.Vector(16, u8);
+const Vec = @Vector(16, u8);
 
 fn reverse_mask(n: u8) Vec {
     // global constant is not used to workaround a compiler bug
@@ -52,14 +52,14 @@ pub fn main() !void {
     var parity: u1 = 0;
     while (true) : (parity +%= 1) {
         const flip_count = pfannkuchen(perm);
-        max_flip_count = std.math.max(max_flip_count, flip_count);
-        checksum += @intCast(i32, flip_count) * (1 - @intCast(i32, parity) * 2);
+        max_flip_count = @max(max_flip_count, flip_count);
+        checksum += @as(i32, @intCast(flip_count)) * (1 - @as(i32, @intCast(parity)) * 2);
         const r = for (count[0..n], 0..) |v, i| {
-            if (v != 1) break @intCast(u8, i);
+            if (v != 1) break @as(u8, @intCast(i));
         } else break;
         perm = apply_mask(perm, r + 1, next_perm_mask);
         count[r] -= 1;
-        for (count[1..r], 0..) |*v, i| v.* = @intCast(u8, i + 2);
+        for (count[1..r], 0..) |*v, i| v.* = @intCast(i + 2);
     }
 
     const stdout = std.io.getStdOut().writer();