@shd101wyy/yo 0.1.29 → 0.1.30

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/scripts/add-pragma-for-pointer-decls.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env bun
+/**
+ * Re-add `pragma(Pragma.AllowUnsafe);` to files that mention raw
+ * pointer types in their declarations (e.g. `*(u8)` in a parameter,
+ * field, or return slot, or `&(x)` to take an address).
+ *
+ * Phase C tightened the structural gate so that `*(T)` and `&(...)`
+ * are themselves rejected in safe code — not just `unsafe(...)`-
+ * wrapped ops like `.* ` and `&+`. The previous trim pass
+ * (scripts/trim-pragma.ts) removed the pragma from files that used
+ * only declarations, which now need it back.
+ *
+ * Detection: file contains `*(<word>` or `&(<word>` outside string
+ * literals / comments. The heuristic is loose on purpose — better
+ * to over-add the pragma than to leave a file failing to compile.
+ *
+ * Usage:
+ *   bun scripts/add-pragma-for-pointer-decls.ts <root-dir>
+ */
+
+import { readFileSync, writeFileSync, statSync, readdirSync } from "fs";
+import { join } from "path";
+import { argv, exit } from "process";
+
+const PRAGMA_LINE = "pragma(Pragma.AllowUnsafe);";
+
+function stripCommentsAndStrings(src: string): string {
+  const out: string[] = [];
+  let inStr: string | null = null;
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i]!;
+    if (!inStr && ch === "/" && src[i + 1] === "/") {
+      while (i < src.length && src[i] !== "\n") i++;
+      continue;
+    }
+    if (inStr) {
+      if (ch === "\\") {
+        out.push(" ", " ");
+        i += 2;
+        continue;
+      }
+      if (ch === inStr) {
+        inStr = null;
+        out.push(" ");
+        i++;
+        continue;
+      }
+      out.push(" ");
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "`") {
+      inStr = ch;
+      out.push(" ");
+      i++;
+      continue;
+    }
+    out.push(ch);
+    i++;
+  }
+  return out.join("");
+}
+
+const POINTER_TYPE_RE = /\*\(/;
+const ADDRESS_OF_RE = /(?:^|[^A-Za-z0-9_])&\(/;
+
+function fileNeedsPragma(src: string): boolean {
+  const cleaned = stripCommentsAndStrings(src);
+  return POINTER_TYPE_RE.test(cleaned) || ADDRESS_OF_RE.test(cleaned);
+}
+
+function fileHasPragma(src: string): boolean {
+  return src.includes("pragma(Pragma.AllowUnsafe)");
+}
+
+/**
+ * Insert the pragma after any leading `//!` module-doc lines and
+ * before the first code declaration. Empty files get the pragma at
+ * the top.
+ */
+function insertPragma(src: string): string {
+  const lines = src.split("\n");
+  let insertAt = 0;
+  // Skip leading shebang / module-doc / blank / line-comment.
+  while (insertAt < lines.length) {
+    const trimmed = lines[insertAt]!.trim();
+    if (
+      trimmed === "" ||
+      trimmed.startsWith("#!") ||
+      trimmed.startsWith("//!") ||
+      trimmed.startsWith("//")
+    ) {
+      insertAt++;
+      continue;
+    }
+    break;
+  }
+  lines.splice(insertAt, 0, PRAGMA_LINE);
+  return lines.join("\n");
+}
+
+function walk(dir: string, out: string[]): void {
+  for (const entry of readdirSync(dir)) {
+    const p = join(dir, entry);
+    const s = statSync(p);
+    if (s.isDirectory()) {
+      if (entry === "node_modules" || entry.startsWith(".")) continue;
+      walk(p, out);
+    } else if (s.isFile() && p.endsWith(".yo")) {
+      out.push(p);
+    }
+  }
+}
+
+const root = argv[2];
+if (!root) {
+  console.error(`usage: bun ${argv[1]} <root-dir>`);
+  exit(1);
+}
+
+const files: string[] = [];
+walk(root, files);
+
+let added = 0;
+for (const file of files) {
+  const src = readFileSync(file, "utf8");
+  if (fileHasPragma(src)) continue;
+  if (!fileNeedsPragma(src)) continue;
+  writeFileSync(file, insertPragma(src));
+  added++;
+  console.log(`added pragma: ${file}`);
+}
+console.log(`---\nadded pragma to ${added} file(s).`);

package/scripts/add-pragma.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+/**
+ * Add `pragma(Pragma.AllowUnsafe);` at the top of every .yo file
+ * passed on the command line, unless it already has one.
+ *
+ * Phase C of plans/MEMORY_SAFETY.md: explicit per-file pragma replaces
+ * the path-based MVP heuristic. Run this once over `std/`, `yo-self/`,
+ * and `tests/` during the migration.
+ *
+ * Heuristics:
+ * - Skip the prelude itself (it defines `Pragma`; the pragma in the
+ *   prelude is placed by hand, mid-file, after `Pragma :: enum(...)`).
+ * - Skip files that already contain `pragma(Pragma.AllowUnsafe);`.
+ * - Insert after any leading `//` line comments at the top of the file
+ *   so the docstring stays visually at the top.
+ */
+
+import { readFileSync, writeFileSync, statSync } from "fs";
+import { argv } from "process";
+
+const PRAGMA_LINE = "pragma(Pragma.AllowUnsafe);";
+
+function processFile(file: string): "added" | "already" | "skip" {
+  const src = readFileSync(file, "utf8");
+  if (file.endsWith("/std/prelude.yo")) return "skip";
+  if (src.includes(PRAGMA_LINE)) return "already";
+
+  const lines = src.split("\n");
+  // Find first non-comment, non-blank line; insert pragma above it.
+  let insertAt = 0;
+  while (insertAt < lines.length) {
+    const ln = lines[insertAt]!.trim();
+    if (ln === "" || ln.startsWith("//") || ln.startsWith("/*")) {
+      insertAt++;
+    } else {
+      break;
+    }
+  }
+  lines.splice(insertAt, 0, PRAGMA_LINE);
+  writeFileSync(file, lines.join("\n"));
+  return "added";
+}
+
+let added = 0;
+let already = 0;
+let skip = 0;
+for (const file of argv.slice(2)) {
+  try {
+    if (!statSync(file).isFile()) continue;
+  } catch {
+    continue;
+  }
+  const r = processFile(file);
+  if (r === "added") added++;
+  else if (r === "already") already++;
+  else skip++;
+}
+console.log(`added: ${added}, already: ${already}, skipped: ${skip}`);

package/scripts/migrate-amp-method-calls.ts

@@ -0,0 +1,186 @@
+/**
+ * Rewrite `(&(X)).METHOD(...)` → `X.METHOD(...)` for methods that
+ * have been migrated from `(self : *(Self))` to `(inout(self) :
+ * Self)`. Inout method dispatch auto-wraps the receiver with
+ * `&(...)`, so the explicit `&(X)` at the call site now produces
+ * `&(&(X))` = `*(*(T))`, which doesn't match the expected `*(T)`.
+ *
+ * The script takes a method-name allow-list (passed via env var
+ * `METHODS` or a hardcoded default list). Receivers `X` can be any
+ * balanced expression; we don't touch the receiver, only strip the
+ * `&(...)` wrap.
+ *
+ * Usage:
+ *   bun run scripts/migrate-amp-method-calls.ts         # dry-run
+ *   bun run scripts/migrate-amp-method-calls.ts --write # apply
+ */
+
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+
+const ROOTS = ["std", "yo-self", "tests"];
+
+// Methods migrated to inout(self) : Self in this session, plus the
+// emitter/Clone/Hash/ToString migrations from earlier. If a method
+// here was actually NOT migrated, no harm — dispatch only changes
+// for the migrated ones, and the rewrite stays semantically
+// correct (`X.method()` already worked for `*(Self)`-style methods
+// via Yo's auto-deref).
+const METHODS = [
+  // Array / Slice
+  "iter",
+  "len",
+  // String mutators
+  "push_str",
+  "push_string",
+  "push_byte",
+  "reserve",
+  "clear",
+  // StringBuilder
+  "is_empty",
+  "write_str",
+  "write_string",
+  "write_byte",
+  "write_rune",
+  "write_line",
+  // Time
+  "as_secs",
+  "as_millis",
+  "as_micros",
+  "as_nanos",
+  "to_string",
+  "duration_since",
+  "elapsed",
+  // Sync / process / thread
+  "lock",
+  "unlock",
+  "signal",
+  "broadcast",
+  "wait",
+  "spawn",
+  "join",
+  // Collections inherent (the few that got migrated)
+  "trim_to_fit",
+  // Existing migrated (Hash, Clone, ToString) — safe no-op if not
+  // explicitly wrapped at the call site
+  "hash",
+  "clone",
+  // Iterator
+  "next",
+];
+
+function matchAmpersandWrap(
+  content: string,
+  start: number
+): { x: string; end: number } | null {
+  if (content.slice(start, start + 3) !== "(&(") return null;
+  let depth = 1;
+  let i = start + 3;
+  const xStart = i;
+  while (i < content.length) {
+    const ch = content[i]!;
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) break;
+    }
+    i++;
+  }
+  if (i >= content.length) return null;
+  const x = content.slice(xStart, i);
+  if (content[i + 1] !== ")") return null;
+  return { x, end: i + 2 };
+}
+
+function migrate(
+  content: string,
+  methodSet: Set<string>
+): { result: string; rewrites: number } {
+  const out: string[] = [];
+  let i = 0;
+  let rewrites = 0;
+  while (i < content.length) {
+    if (content.slice(i, i + 3) !== "(&(") {
+      out.push(content[i]!);
+      i++;
+      continue;
+    }
+    const wrap = matchAmpersandWrap(content, i);
+    if (!wrap) {
+      out.push(content[i]!);
+      i++;
+      continue;
+    }
+    // After `(&(X))`, look for `.METHOD(`.
+    if (content[wrap.end] !== ".") {
+      out.push(content[i]!);
+      i++;
+      continue;
+    }
+    // Extract method name.
+    const methodMatch = content
+      .slice(wrap.end + 1)
+      .match(/^([A-Za-z_][A-Za-z0-9_]*)\(/);
+    if (!methodMatch) {
+      out.push(content[i]!);
+      i++;
+      continue;
+    }
+    const method = methodMatch[1]!;
+    if (!methodSet.has(method)) {
+      out.push(content[i]!);
+      i++;
+      continue;
+    }
+    // Rewrite: `(&(X))` → `X`. Keep `.method(` as-is.
+    out.push(wrap.x);
+    i = wrap.end;
+    rewrites++;
+  }
+  return { result: out.join(""), rewrites };
+}
+
+function* walk(dir: string): Generator<string> {
+  for (const entry of readdirSync(dir)) {
+    if (entry.startsWith(".")) continue;
+    const fullPath = path.join(dir, entry);
+    const st = statSync(fullPath);
+    if (st.isDirectory()) {
+      yield* walk(fullPath);
+    } else if (st.isFile() && entry.endsWith(".yo")) {
+      yield fullPath;
+    }
+  }
+}
+
+function main(): void {
+  const write = process.argv.includes("--write");
+  const methodsFromEnv = process.env.METHODS;
+  const methodList = methodsFromEnv ? methodsFromEnv.split(",") : METHODS;
+  const methodSet = new Set(methodList);
+  let total = 0;
+  let filesTouched = 0;
+  for (const root of ROOTS) {
+    const absRoot = path.resolve(root);
+    for (const filePath of walk(absRoot)) {
+      const content = readFileSync(filePath, "utf-8");
+      const { result, rewrites } = migrate(content, methodSet);
+      if (result === content) continue;
+      filesTouched++;
+      total += rewrites;
+      console.log(
+        `${write ? "migrated" : "would migrate"}: ${path.relative(
+          process.cwd(),
+          filePath
+        )} (${rewrites})`
+      );
+      if (write) writeFileSync(filePath, result, "utf-8");
+    }
+  }
+  console.log(
+    `\n${write ? "Migrated" : "Would migrate"} ${total} call sites across ${filesTouched} file(s).`
+  );
+  if (!write) console.log("(dry-run — pass --write to apply)");
+}
+
+main();

package/scripts/migrate-clone-calls.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+/**
+ * Migrate `(&(x)).clone()` to `x.clone()` in the given files.
+ *
+ * Phase D of plans/MEMORY_SAFETY.md: Clone trait now takes
+ * `inout(self) : Self` instead of `(self : *(Self))`, so the old
+ * pattern `(&(x)).clone()` (passing a `*(T)` to a `*(Self)` receiver)
+ * no longer matches. The caller can just write `x.clone()` and the
+ * compiler auto-wraps for the inout calling convention.
+ *
+ * Match: `(&(EXPR)).clone()` — handles balanced parens inside EXPR.
+ * Replace with `EXPR.clone()`. Conservative: only single-line matches.
+ */
+
+import { readFileSync, writeFileSync } from "fs";
+import { argv } from "process";
+
+function matchedClose(s: string, openPos: number): number {
+  // openPos is the position of `(`. Return position of matching `)`.
+  let depth = 1;
+  let i = openPos + 1;
+  let inStr: string | null = null;
+  while (i < s.length) {
+    const ch = s[i]!;
+    if (inStr) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === inStr) inStr = null;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "`") {
+      inStr = ch;
+      i++;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+    i++;
+  }
+  return -1;
+}
+
+function migrate(src: string): string {
+  let out = "";
+  let i = 0;
+  while (i < src.length) {
+    // Look for `(&(` start.
+    if (src.slice(i, i + 3) === "(&(") {
+      const inner_open = i + 2; // position of inner `(`
+      const inner_close = matchedClose(src, inner_open);
+      if (inner_close < 0) {
+        out += src[i]!;
+        i++;
+        continue;
+      }
+      const outer_close = matchedClose(src, i);
+      if (outer_close < 0 || outer_close !== inner_close + 1) {
+        out += src[i]!;
+        i++;
+        continue;
+      }
+      // Check that the trailing chars are `.clone()`.
+      const trailing = src.slice(outer_close + 1, outer_close + 9);
+      if (trailing === ".clone()") {
+        const inner = src.slice(inner_open + 1, inner_close);
+        out += `${inner}.clone()`;
+        i = outer_close + 9;
+        continue;
+      }
+    }
+    out += src[i]!;
+    i++;
+  }
+  return out;
+}
+
+let changed = 0;
+for (const file of argv.slice(2)) {
+  const src = readFileSync(file, "utf8");
+  const next = migrate(src);
+  if (next !== src) {
+    writeFileSync(file, next);
+    changed++;
+    console.log(`migrated: ${file}`);
+  }
+}
+console.log(`done: ${changed} file(s) changed`);

package/scripts/migrate-get-unwrap.ts

@@ -0,0 +1,166 @@
+/**
+ * Replace `X.get(IDX).unwrap()` with `X(IDX)`.
+ *
+ * `X.get(idx)` on an indexable type (ArrayList, Deque, HashMap,
+ * BTreeMap, String, Array, imm Vec, etc.) returns `Option(T)`.
+ * Calling `.unwrap()` panics on a missing element. Yo's Index-trait
+ * call-syntax `X(idx)` returns `T` directly and panics identically
+ * (via the trait's bounds assertion).
+ *
+ * The substitution is safe whenever:
+ *   1. `X.get(...)` has exactly ONE argument.
+ *   2. `X` is followed by `.get(...)` then immediately `.unwrap()`.
+ *   3. The receiver type implements Index — for which we have no
+ *      type info here, but it covers the vast majority of cases
+ *      since Option/Result don't have `.get(IDX)` shape (Option has
+ *      no `.get` at all; Result.ok() returns Option).
+ *
+ * Skipped:
+ *   - `X.get(K, V).unwrap()` — multi-arg get (not Index trait).
+ *   - `X.get().unwrap()` — zero-arg get.
+ *   - Bare `.get(...)` without `.unwrap()`.
+ *   - Anything followed by another `.method(...)` chain after
+ *     `.unwrap()` — we leave the result chain alone (still works
+ *     since `X(i)` returns the same type as `X.get(i).unwrap()`).
+ *
+ * Usage:
+ *   bun run scripts/migrate-get-unwrap.ts         # dry-run
+ *   bun run scripts/migrate-get-unwrap.ts --write # apply
+ */
+
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+
+const ROOTS = ["std", "yo-self", "tests"];
+
+/**
+ * Walk a balanced parenthesized group starting at `start` (where
+ * `content[start]` is `(`). Returns the inner content and the index
+ * just after the closing `)`. Returns null on unbalanced input.
+ */
+function matchBalancedParens(
+  content: string,
+  start: number
+): { inner: string; end: number } | null {
+  if (content[start] !== "(") return null;
+  let depth = 1;
+  let i = start + 1;
+  const innerStart = i;
+  while (i < content.length) {
+    const ch = content[i]!;
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        return { inner: content.slice(innerStart, i), end: i + 1 };
+      }
+    }
+    i++;
+  }
+  return null;
+}
+
+/**
+ * Count top-level commas in `s` — useful for detecting multi-arg
+ * function calls. Skips commas inside nested parens / brackets / braces.
+ */
+function topLevelCommaCount(s: string): number {
+  let count = 0;
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]!;
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "," && depth === 0) count++;
+  }
+  return count;
+}
+
+function migrate(content: string): { result: string; rewrites: number } {
+  let rewrites = 0;
+  // We scan for the literal `.get(`, then walk:
+  //   ... `.get(` BALANCED `)` `.unwrap()`
+  // and rewrite the entire span back to `(` BALANCED `)`.
+  //
+  // The receiver `X` is whatever precedes `.get(`. We DO NOT rewrite
+  // the receiver — just leave it in place and append `(args)` after
+  // it. That way `foo.bar.get(i).unwrap()` becomes `foo.bar(i)`.
+  const out: string[] = [];
+  let i = 0;
+  while (i < content.length) {
+    const idx = content.indexOf(".get(", i);
+    if (idx === -1) {
+      out.push(content.slice(i));
+      break;
+    }
+    out.push(content.slice(i, idx));
+    const argStart = idx + 4;
+    const args = matchBalancedParens(content, argStart);
+    if (!args) {
+      out.push(content[i]!);
+      i++;
+      continue;
+    }
+    // Check for `.unwrap()` immediately after.
+    if (content.slice(args.end, args.end + 9) !== ".unwrap()") {
+      // Not a `.get(IDX).unwrap()` pair — leave alone.
+      out.push(content.slice(idx, args.end));
+      i = args.end;
+      continue;
+    }
+    // Require exactly one top-level arg (skip empty-arg get, skip
+    // 2+arg get). Allow whitespace-only emptiness check.
+    if (args.inner.trim().length === 0 || topLevelCommaCount(args.inner) > 0) {
+      out.push(content.slice(idx, args.end + 9));
+      i = args.end + 9;
+      continue;
+    }
+    // Rewrite: `.get(IDX).unwrap()` → `(IDX)`.
+    out.push(`(${args.inner})`);
+    rewrites++;
+    i = args.end + 9; // skip past `.unwrap()`
+  }
+  return { result: out.join(""), rewrites };
+}
+
+function* walk(dir: string): Generator<string> {
+  for (const entry of readdirSync(dir)) {
+    if (entry.startsWith(".")) continue;
+    const fullPath = path.join(dir, entry);
+    const st = statSync(fullPath);
+    if (st.isDirectory()) {
+      yield* walk(fullPath);
+    } else if (st.isFile() && entry.endsWith(".yo")) {
+      yield fullPath;
+    }
+  }
+}
+
+function main(): void {
+  const write = process.argv.includes("--write");
+  let totalRewrites = 0;
+  let filesTouched = 0;
+  for (const root of ROOTS) {
+    const absRoot = path.resolve(root);
+    for (const filePath of walk(absRoot)) {
+      const content = readFileSync(filePath, "utf-8");
+      const { result, rewrites } = migrate(content);
+      if (result === content) continue;
+      filesTouched++;
+      totalRewrites += rewrites;
+      console.log(
+        `${write ? "migrated" : "would migrate"}: ${path.relative(
+          process.cwd(),
+          filePath
+        )} (${rewrites})`
+      );
+      if (write) writeFileSync(filePath, result, "utf-8");
+    }
+  }
+  console.log(
+    `\n${write ? "Migrated" : "Would migrate"} ${totalRewrites} rewrites across ${filesTouched} file(s).`
+  );
+  if (!write) console.log("(dry-run — pass --write to apply)");
+}
+
+main();