[pull] master from GaijinEntertainment:master

.githooks/README.md

@@ -0,0 +1,50 @@
+# Repo-managed git hooks
+
+Tracked hooks that mirror CI checks. Cross-platform: Linux, macOS, Windows (Git Bash).
+
+## Enable (once per clone)
+
+```sh
+git config core.hooksPath .githooks
+```
+
+Reverts via `git config --unset core.hooksPath`. Skip once with `git push --no-verify`.
+
+### Windows notes
+
+- Git for Windows ships Git Bash — the `#!/usr/bin/env bash` shebang works out of the box. No extra install needed.
+- If you use PowerShell or `cmd` for `git push`, that's fine — git invokes the hook through its own shell, not yours.
+- File-mode permissions are ignored on Windows; just having the file in `.githooks/` is enough.
+
+### Linux / macOS
+
+Hooks must be executable. Cloning preserves the executable bit (it's set in the repo via `git update-index --chmod=+x`). If you ever lose it locally:
+
+```sh
+chmod +x .githooks/*
+```
+
+## Hooks
+
+- **pre-push** — formatter (`--verify` on the whole tree) + lint on pushed `.das` files. Mirrors `.github/workflows/extended_checks.yml`.
+
+## Requirements
+
+A built `daslang` binary. The script auto-detects:
+
+- `bin/daslang` (Linux / macOS, single-config Make/Ninja)
+- `bin/daslang.exe` (MSYS / cygwin)
+- `bin/Release/daslang.exe` / `bin/Debug/daslang.exe` (Windows MSVC)
+- `build/daslang`, `build/bin/daslang`
+
+Build before pushing:
+
+```sh
+cmake --build build --target daslang
+```
+
+Override the resolved path:
+
+```sh
+DASLANG=/custom/path/daslang git push
+```

.githooks/pre-push

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# pre-push: mirror CI's formatter + lint (.github/workflows/extended_checks.yml).
+# Cross-platform: runs under Git Bash on Windows, bash on Linux/macOS.
+#
+# Enable per-clone:
+#   git config core.hooksPath hooks
+# Skip once:
+#   git push --no-verify
+# Override binary path:
+#   DASLANG=/path/to/daslang git push
+
+set -eu
+
+ROOT="$(git rev-parse --show-toplevel)"
+cd "$ROOT"
+
+# Resolve daslang binary across single/multi-config layouts.
+resolve_daslang() {
+    if [ -n "${DASLANG:-}" ] && [ -x "$DASLANG" ]; then
+        echo "$DASLANG"; return
+    fi
+    for p in \
+        "$ROOT/bin/daslang" \
+        "$ROOT/bin/daslang.exe" \
+        "$ROOT/bin/Release/daslang.exe" \
+        "$ROOT/bin/Debug/daslang.exe" \
+        "$ROOT/build/daslang" \
+        "$ROOT/build/bin/daslang"
+    do
+        [ -x "$p" ] && { echo "$p"; return; }
+    done
+    return 1
+}
+
+DASLANG="$(resolve_daslang || true)"
+if [ -z "$DASLANG" ]; then
+    echo "pre-push: daslang not found — build it (cmake --build build --target daslang)" >&2
+    echo "         or set DASLANG=/path/to/daslang" >&2
+    exit 1
+fi
+
+echo "pre-push: using $DASLANG"
+
+# Formatter: whole tree, verify-only (CI parity).
+echo "pre-push: formatter --verify ..."
+"$DASLANG" "$ROOT/utils/das-fmt/dasfmt.das" -- --path "$ROOT" --verify
+
+# Lint: only .das files changed in the pushed range vs remote tip
+# (mirrors CI's `git diff origin/<base>...HEAD`).
+ZERO40="0000000000000000000000000000000000000000"
+ZERO64="0000000000000000000000000000000000000000000000000000000000000000"
+RANGES=()
+while read -r LOCAL_REF LOCAL_SHA REMOTE_REF REMOTE_SHA; do
+    case "$LOCAL_SHA" in "$ZERO40"|"$ZERO64") continue;; esac  # branch delete
+    case "$REMOTE_SHA" in
+        "$ZERO40"|"$ZERO64")
+            BASE="$(git merge-base "$LOCAL_SHA" origin/master 2>/dev/null || true)"
+            [ -n "$BASE" ] && RANGES+=("$BASE..$LOCAL_SHA")
+            ;;
+        *)
+            RANGES+=("$REMOTE_SHA..$LOCAL_SHA")
+            ;;
+    esac
+done
+
+if [ ${#RANGES[@]} -eq 0 ]; then
+    echo "pre-push: no ranges (deleting or empty); skipping lint"
+    exit 0
+fi
+
+# Portable read-into-array (mapfile is bash 4+; macOS default ships bash 3.2).
+CHANGED=()
+while IFS= read -r line; do
+    CHANGED+=("$line")
+done < <(git diff --name-only --diff-filter=AM "${RANGES[@]}" -- '*.das' | sort -u)
+
+if [ ${#CHANGED[@]} -eq 0 ]; then
+    echo "pre-push: no .das files changed; skipping lint"
+    exit 0
+fi
+
+echo "pre-push: linting ${#CHANGED[@]} .das file(s)"
+"$DASLANG" "$ROOT/utils/lint/main.das" -- "${CHANGED[@]}" --quiet

benchmarks/fusion/bench_arr_at_i64.das

@@ -0,0 +1,82 @@
+options gen2
+
+require dastest/testing_boost
+
+// Apples-to-apples cost of int / int64 / uint64-indexed array access.
+// All three benches use the same `for (i in <range-iter>(N))` shape,
+// differing only in the index type. Write workload is `arr[i] = 1`
+// (no cast in the body — isolates the index/fusion cost). The outer
+// `for (j in range(OUTER))` amortizes the per-body harness overhead
+// over OUTER * N inner ops.
+
+let N = 10000
+let OUTER = 10
+let TOTAL = N * OUTER
+
+[benchmark]
+def arr_at_int_idx(b : B?) {
+    var arr : array<int>
+    arr |> resize(N)
+    b |> run("write_int_idx/{TOTAL}", TOTAL) {
+        for (_j in range(OUTER)) {
+            for (i in range(N)) {
+                arr[i] = 1
+            }
+        }
+    }
+    b |> run("read_int_idx/{TOTAL}", TOTAL) {
+        var sum = 0
+        for (_j in range(OUTER)) {
+            for (i in range(N)) {
+                sum += arr[i]
+            }
+        }
+        strictEqual(b, length(arr), N)
+    }
+}
+
+[benchmark]
+def arr_at_int64_idx(b : B?) {
+    var arr : array<int>
+    arr |> resize(N)
+    let N64 = int64(N)
+    b |> run("write_int64_idx/{TOTAL}", TOTAL) {
+        for (_j in range(OUTER)) {
+            for (i in range64(N64)) {
+                arr[i] = 1
+            }
+        }
+    }
+    b |> run("read_int64_idx/{TOTAL}", TOTAL) {
+        var sum = 0
+        for (_j in range(OUTER)) {
+            for (i in range64(N64)) {
+                sum += arr[i]
+            }
+        }
+        strictEqual(b, length(arr), N)
+    }
+}
+
+[benchmark]
+def arr_at_uint64_idx(b : B?) {
+    var arr : array<int>
+    arr |> resize(N)
+    let N64 = uint64(N)
+    b |> run("write_uint64_idx/{TOTAL}", TOTAL) {
+        for (_j in range(OUTER)) {
+            for (i in urange64(N64)) {
+                arr[i] = 1
+            }
+        }
+    }
+    b |> run("read_uint64_idx/{TOTAL}", TOTAL) {
+        var sum = 0
+        for (_j in range(OUTER)) {
+            for (i in urange64(N64)) {
+                sum += arr[i]
+            }
+        }
+        strictEqual(b, length(arr), N)
+    }
+}

benchmarks/fusion/bench_table_index_i64.das

@@ -0,0 +1,66 @@
+options gen2
+
+require dastest/testing_boost
+
+// Apples-to-apples cost of int / int64 / uint64-keyed table indexing.
+// All three benches use the same `for (k in <range-iter>(N))` shape,
+// differing only in the key type. Read workload is `sum += tab[k]`
+// (no cast in the body). The outer `for (j in range(OUTER))` amortizes
+// per-body harness overhead over OUTER * N inner ops.
+
+let N = 10000
+let OUTER = 10
+let TOTAL = N * OUTER
+
+[benchmark]
+def table_index_int_key(b : B?) {
+    var tab : table<int; int>
+    for (k in range(N)) {
+        tab[k] = 1
+    }
+    b |> run("read_int_key/{TOTAL}", TOTAL) {
+        var sum = 0
+        for (_j in range(OUTER)) {
+            for (k in range(N)) {
+                sum += tab[k]
+            }
+        }
+        strictEqual(b, length(tab), N)
+    }
+}
+
+[benchmark]
+def table_index_int64_key(b : B?) {
+    var tab : table<int64; int>
+    let N64 = int64(N)
+    for (k in range64(N64)) {
+        tab[k] = 1
+    }
+    b |> run("read_int64_key/{TOTAL}", TOTAL) {
+        var sum = 0
+        for (_j in range(OUTER)) {
+            for (k in range64(N64)) {
+                sum += tab[k]
+            }
+        }
+        strictEqual(b, length(tab), N)
+    }
+}
+
+[benchmark]
+def table_index_uint64_key(b : B?) {
+    var tab : table<uint64; int>
+    let N64 = uint64(N)
+    for (k in urange64(N64)) {
+        tab[k] = 1
+    }
+    b |> run("read_uint64_key/{TOTAL}", TOTAL) {
+        var sum = 0
+        for (_j in range(OUTER)) {
+            for (k in urange64(N64)) {
+                sum += tab[k]
+            }
+        }
+        strictEqual(b, length(tab), N)
+    }
+}

benchmarks/sql/LINQ.md

@@ -778,3 +778,7 @@ dastest reports `ns/op` in INTERP mode by default. To bump dataset size as the s
 **`PERF009` suppression in `fold_linq_default`.** The macro's `var pass_N = call` + later `return <- pass_N` pattern triggers PERF009 on single-pass chains. The shape is load-bearing for the array-pipeline semantics (every stage binds so the next can reuse the buffer in-place), so we suppress inline at the qmacro_expr emission site and document why.
 
 **Benchmark variants where SQL has no clean form.** `zip` (not a relational op), `_all(pred)` (no direct `_all` chain terminal in sqlite_linq), `join` with inner-select-from (wiring not exposed), `distinct |> count` (no `COUNT(DISTINCT col)` yet), `take/skip` before aggregate (LIMIT/OFFSET semantics conflict with aggregate-collapse). We either reformulate to a SQL-friendly shape (`count(where ¬p)` for all_match), omit the m1 column (zip, join), or terminate the chain in `to_array` instead of an aggregate (take/skip/distinct).
+
+## Future work — 64-bit sweep
+
+Gated on 64-bit arrays + tables landing in daslang. Once they do, sweep `daslib/linq.das` to add `int64` overloads on every count/index/N-parameter surface. Today only the count family is symmetric — `count(iter; pred)` / `count(arr; pred)` / `long_count(iter; pred)` / `long_count(arr; pred)` all exist with their bare (no-pred) forms. The rest of the surface (`take(N)`, `skip(N)`, `skip_last(N)`, `take_last(N)`, `top_n(N)`, `top_n_by(N)`, `top_n_by_descending(N)`, `top_n_by_with_cmp(N)`, `element_at(N)`) still takes `int` only. Add `int64` overloads alongside, route splice planners to pick the matching variant by argument type, and refresh benchmarks for the large-N regime.