@shd101wyy/yo 0.1.26 → 0.1.28

package/package.json

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

package/scripts/probe-parser-parity.ts

@@ -0,0 +1,61 @@
+// Probe: for each .yo file in tests/ and yo-self/, parse via TS and check
+// if yo-self's parser via `yo-self compile --emit-c --skip-c-compiler` also
+// succeeds (or fails for the same reason).
+//
+// We don't actually compile — we just lex+parse+evaluate enough to detect
+// parser errors. But yo-self's `compile` subcommand runs the full pipeline
+// which includes evaluation. So we use a lighter probe: try compiling
+// from a tiny stub `main.yo` that imports each file.
+//
+// Simpler: just use the TS parser. If any file fails to TS-parse, log it.
+// Then optionally compare with yo-self by running yo-self-bin and seeing
+// if it also fails.
+import Parser from "../src/parser";
+import * as fs from "fs";
+import * as path from "path";
+
+function walk(dir: string, files: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return files;
+  const stat = fs.statSync(dir);
+  if (stat.isFile() && dir.endsWith(".yo")) {
+    files.push(dir);
+    return files;
+  }
+  if (stat.isDirectory()) {
+    for (const entry of fs.readdirSync(dir)) {
+      if ([".git", "node_modules", "out", "yo-out"].includes(entry)) continue;
+      walk(path.join(dir, entry), files);
+    }
+  }
+  return files;
+}
+
+const files = [
+  ...walk("tests"),
+  ...walk("yo-self"),
+];
+
+console.log(`Found ${files.length} .yo files\n`);
+let tsOk = 0, tsFail = 0;
+const tsFailures: { file: string; err: string }[] = [];
+
+for (const f of files) {
+  const src = fs.readFileSync(f, "utf-8");
+  try {
+    const p = new Parser({ inputString: src, modulePath: f });
+    p.getProgram();
+    tsOk++;
+  } catch (e) {
+    tsFail++;
+    tsFailures.push({ file: f, err: String(e).split("\n")[0].slice(0, 120) });
+  }
+}
+
+console.log(`TS parser: ${tsOk} OK, ${tsFail} fail`);
+if (tsFailures.length > 0 && tsFailures.length < 30) {
+  console.log("\nTS failures:");
+  for (const f of tsFailures.slice(0, 20)) {
+    console.log(`  ${f.file}`);
+    console.log(`    ${f.err}`);
+  }
+}

package/scripts/probe-yo-self-parser.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Run yo-self-bin fmt on every .yo file, count fail/success.
+BIN=/tmp/yo-self-fmt-bin
+OK=0; FAIL=0; FAILS=()
+
+while IFS= read -r f; do
+  # Copy to a temp so original isn't modified.
+  tmp="/tmp/yo_parse_probe_$$.yo"
+  cp "$f" "$tmp"
+  if "$BIN" fmt --check "$tmp" >/dev/null 2>&1 ; then
+    OK=$((OK+1))
+  else
+    # --check may exit 1 for "would format" — that's OK. Check stderr.
+    out=$("$BIN" fmt --check "$tmp" 2>&1)
+    rc=$?
+    if [ "$rc" = "0" ] || [ "$rc" = "1" ]; then
+      OK=$((OK+1))
+    else
+      FAIL=$((FAIL+1))
+      FAILS+=("$f: $out")
+    fi
+  fi
+  rm -f "$tmp"
+done < <(find tests yo-self -name "*.yo" 2>/dev/null)
+
+echo "OK: $OK   FAIL: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+  echo
+  echo "Failures (first 10):"
+  for f in "${FAILS[@]:0:10}"; do
+    echo "  - $f"
+  done
+fi

package/scripts/validate-yo-self-fmt.ts

@@ -0,0 +1,184 @@
+// One-off validation: extract each test() block from src/tests/formatter.test.ts,
+// run yo-self-bin fmt on the source, compare to the inline expected output.
+//
+// Usage: bun /tmp/validate-yo-self-fmt.ts
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+
+const BIN = "/tmp/yo-self-fmt-bin";
+const TEST_FILE = "src/tests/formatter.test.ts";
+
+const source = fs.readFileSync(TEST_FILE, "utf-8");
+
+// Match each `test("name", () => { ... });` block at the top level.
+// Within: extract `const source = (template-literal);` and the final
+// `expect(formatYoSource(source)).toBe(template-literal);`.
+//
+// Template literals may contain newlines, embedded ${...}, and escaped backticks.
+// We use a state-machine over the source to find balanced backtick-delimited
+// template literals starting at a given position.
+function findTemplateLiteral(
+  s: string,
+  start: number
+): { value: string; end: number } | null {
+  if (s[start] !== "`") return null;
+  let i = start + 1;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "`") {
+      // Closing backtick.
+      return { value: s.slice(start, i + 1), end: i + 1 };
+    }
+    if (c === "$" && s[i + 1] === "{") {
+      // Skip the ${...} interpolation balanced by curlies.
+      let depth = 1;
+      i += 2;
+      while (i < s.length && depth > 0) {
+        if (s[i] === "{") depth++;
+        else if (s[i] === "}") depth--;
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return null;
+}
+
+function findStringLiteral(
+  s: string,
+  start: number
+): { value: string; end: number } | null {
+  if (s[start] !== '"' && s[start] !== "'" && s[start] !== "`") return null;
+  if (s[start] === "`") return findTemplateLiteral(s, start);
+  const quote = s[start];
+  let i = start + 1;
+  while (i < s.length) {
+    if (s[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (s[i] === quote) return { value: s.slice(start, i + 1), end: i + 1 };
+    i++;
+  }
+  return null;
+}
+
+// Parse all test("name", () => { ... }); blocks.
+//
+// Anchor matching on `test("name", () => {` so we don't mistake
+// `test("name", { … })` substrings that appear inside test source/expected
+// template literals (e.g. test 7's source includes a literal
+// `test("format effect", { … })`). The `() =>` arrow distinguishes a real
+// top-level `test()` call from the inner content.
+type TestCase = { name: string; source: string; expected: string };
+const cases: TestCase[] = [];
+const skipped: { name: string; reason: string }[] = [];
+
+const testStartRe = /test\("([^"]+)",\s*\(\s*\)\s*=>\s*\{/g;
+let m: RegExpExecArray | null;
+while ((m = testStartRe.exec(source)) !== null) {
+  const name = m[1];
+  const p = m.index + m[0].length;
+
+  // Find `const source = `...`;`
+  const srcMarker = "const source = ";
+  const srcIdx = source.indexOf(srcMarker, p);
+  if (srcIdx === -1) {
+    skipped.push({ name, reason: "no `const source = `" });
+    continue;
+  }
+  const srcLitStart = srcIdx + srcMarker.length;
+  const srcLit = findStringLiteral(source, srcLitStart);
+  if (!srcLit) {
+    skipped.push({ name, reason: "source is not a string literal" });
+    continue;
+  }
+
+  // Find the first `.toBe(` after the source declaration. Most tests use
+  // `expect(formatYoSource(source)).toBe(`<literal>`)` but some use the
+  // intermediate `const once = formatYoSource(source); expect(once).toBe(`<literal>`)`
+  // form — both are caught here because the first `.toBe(` carries the
+  // literal. Tests that compare two identifiers (e.g. `expect(twice).toBe(once)`
+  // for idempotency-only checks) have no literal to compare and are skipped.
+  const expMarker = ".toBe(";
+  const expIdx = source.indexOf(expMarker, srcLit.end);
+  if (expIdx === -1) {
+    skipped.push({ name, reason: "no `.toBe(` after source" });
+    continue;
+  }
+  let expLitStart = expIdx + expMarker.length;
+  while (/\s/.test(source[expLitStart])) expLitStart++;
+  const expLit = findStringLiteral(source, expLitStart);
+  if (!expLit) {
+    skipped.push({
+      name,
+      reason:
+        "`.toBe(` argument is not a string literal (idempotency-only test?)",
+    });
+    continue;
+  }
+
+  // eval the literals (template-strings with embedded vars: those aren't used
+  // in our test cases except for backslash-escaped backticks)
+  let srcValue: string, expectedValue: string;
+  try {
+    srcValue = eval(srcLit.value);
+    expectedValue = eval(expLit.value);
+  } catch (e) {
+    skipped.push({ name, reason: `eval failed: ${e}` });
+    continue;
+  }
+  cases.push({ name, source: srcValue, expected: expectedValue });
+}
+
+console.log(
+  `Extracted ${cases.length} test cases; skipped ${skipped.length}.\n`
+);
+if (skipped.length > 0) {
+  console.log("Skipped:");
+  for (const s of skipped) {
+    console.log(`  - ${s.name}: ${s.reason}`);
+  }
+  console.log();
+}
+
+// Run each through yo-self-bin
+let pass = 0,
+  fail = 0;
+const failures: { name: string; expected: string; actual: string }[] = [];
+
+for (const tc of cases) {
+  const tmpPath = `/tmp/yo_fmt_${Date.now()}_${Math.floor(Math.random() * 1e9)}.yo`;
+  fs.writeFileSync(tmpPath, tc.source);
+  spawnSync(BIN, ["fmt", tmpPath], { encoding: "utf-8" });
+  const actual = fs.readFileSync(tmpPath, "utf-8");
+  fs.unlinkSync(tmpPath);
+
+  if (actual === tc.expected) {
+    console.log(`✓ ${tc.name}`);
+    pass++;
+  } else {
+    console.log(`✗ ${tc.name}`);
+    failures.push({ name: tc.name, expected: tc.expected, actual });
+    fail++;
+  }
+}
+
+console.log(`\n${pass} passed, ${fail} failed, ${pass + fail} total\n`);
+
+if (failures.length > 0) {
+  console.log("=== first 5 failures ===\n");
+  for (const f of failures.slice(0, 5)) {
+    console.log(`--- ${f.name} ---`);
+    console.log("expected:");
+    console.log(JSON.stringify(f.expected));
+    console.log("actual:");
+    console.log(JSON.stringify(f.actual));
+    console.log();
+  }
+}

package/std/alg/hash.yo

@@ -2,37 +2,29 @@
 //!
 //! A fast, non-cryptographic hash function with good distribution.
 //! Used internally by `HashMap` and `HashSet`.
-
 /// FNV offset basis constant (0xcbf29ce484222325).
 FNV_OFFSET_BASIS :: u64(14695981039346656037);
 /// FNV prime constant (0x100000001b3).
 FNV_PRIME :: u64(1099511628211);
-
 /// Hash a byte sequence using FNV-1a.
-fnv1a_hash_bytes :: (fn(bytes: *(u8), length: usize) -> u64)
-  {
-    hash := FNV_OFFSET_BASIS;
-    i := usize(0);
-    while(i < length, i = (i + usize(1)), {
-      byte := (bytes &+ i).*;
-      xor := (hash ^ u64(byte));
-      hash = (xor * FNV_PRIME);
-    });
-    return hash;
-  }
-;
-
+fnv1a_hash_bytes :: (fn(bytes : *(u8), length : usize) -> u64)({
+  hash := FNV_OFFSET_BASIS;
+  i := usize(0);
+  while(i < length, i = (i + usize(1)), {
+    byte := (bytes &+ i).*;
+    xor := (hash ^ u64(byte));
+    hash = (xor * FNV_PRIME);
+  });
+  return(hash);
+});
 /// Combine two hash values using `hash * 31 + other`.
 ///
 /// The constant 31 is chosen because it is prime, close to a power of 2
 /// (fast multiplication), and proven effective in practice.
-hash_combine :: (fn(hash: u64, other: u64) -> u64)
-  ((hash * u64(31)) + other)
-;
-
-export
+hash_combine :: (fn(hash : u64, other : u64) -> u64)((hash * u64(31)) + other);
+export(
   fnv1a_hash_bytes,
   hash_combine,
   FNV_OFFSET_BASIS,
   FNV_PRIME
-;
+);

package/std/allocator.yo

@@ -1,7 +1,5 @@
 //! Memory allocation abstractions and global allocator interface.
-
-{ SIZE_MAX } :: import "./libc/stdint.yo";
-
+{ SIZE_MAX } :: import("./libc/stdint.yo");
 /// Memory allocation error variants.
 AllocError :: enum(
   /// Allocator ran out of memory.
@@ -13,93 +11,80 @@ AllocError :: enum(
   /// Pointer passed to dealloc/realloc is invalid.
   InvalidPointer
 );
-
 /// Describes the size and alignment requirements for a memory allocation.
 Layout :: struct(
   /// Size in bytes.
-  size: usize,
+  size : usize,
   /// Alignment in bytes (must be a power of two).
-  alignment: usize
+  alignment : usize
 );
-
 /// Get the memory layout (size and alignment) of a type at compile time.
 layout_of ::
-  (fn(comptime(T): Type) -> comptime(Layout))
+  (fn(comptime(T) : Type) -> comptime(Layout))(
     Layout(
-      size: sizeof(T),
-      alignment: alignof(T)
+      size : sizeof(T),
+      alignment : alignof(T)
     )
-;
-
+  );
 /// Check if allocating `count` elements of type T would overflow `usize`.
-size_would_overflow :: 
-  (fn(comptime(T): Type, count: usize) -> bool) {
+size_would_overflow ::
+  (fn(comptime(T) : Type, count : usize) -> bool)({
     type_size :: sizeof(T);
     cond(
       (type_size == usize(0)) => false,
       true => (count > (SIZE_MAX / type_size))
     )
-  };
-
+  });
 /// User-implementable memory allocator interface.
 /// Implement this trait to provide custom allocation strategies.
 CustomAllocator :: trait(
   /// Allocate memory for `count` items of type T.
-  alloc : (fn(self : *(Self), comptime(T): Type, count: usize) -> Result(?*(T), AllocError)),
-
+  alloc : (fn(self : *(Self), comptime(T) : Type, count : usize) -> Result(?*(T), AllocError)),
   /// Allocate zeroed memory for `count` items of type T.
-  alloc_zeroed : (fn(self : *(Self), comptime(T): Type, count: usize) -> Result(?*(T), AllocError)),
-
+  alloc_zeroed : (fn(self : *(Self), comptime(T) : Type, count : usize) -> Result(?*(T), AllocError)),
   /// Allocate aligned memory for `count` items of type T with the given alignment.
-  alloc_aligned : (fn(self : *(Self), comptime(T): Type, count: usize, alignment: usize) -> Result(?*(T), AllocError)),
-
+  alloc_aligned : (fn(self : *(Self), comptime(T) : Type, count : usize, alignment : usize) -> Result(?*(T), AllocError)),
   /// Reallocate memory to `new_count` items, preserving existing data.
   realloc : (fn(forall(T : Type), self : *(Self), old_ptr : ?*(T), new_count : usize) -> Result(?*(T), AllocError)),
-
   /// Deallocate memory pointed to by `ptr`.
   dealloc : (fn(forall(T : Type), self : *(Self), ptr : *(T)) -> Result(unit, AllocError))
 );
-
 /// Type-erased dynamic allocator wrapping any `CustomAllocator` implementation.
 Allocator :: Dyn(CustomAllocator);
-
-extern "Yo",
-  __yo_malloc : 
-    fn(size: usize) -> ?*(void),
+extern(
+  "Yo",
+  __yo_malloc :
+    fn(size : usize) -> ?*(void),
   __yo_calloc :
-    fn(nmemb: usize, size: usize) -> ?*(void),
+    fn(nmemb : usize, size : usize) -> ?*(void),
   __yo_realloc :
     fn(ptr : ?*(void), size : usize) -> ?*(void),
   __yo_free :
     fn(ptr : ?*(void)) -> unit,
   __yo_aligned_alloc :
     fn(alignment : usize, size : usize) -> ?*(void)
-;
-
+);
 /// The process-wide global allocator (mimalloc by default, falls back to libc).
-GlobalAllocator :: impl {
+GlobalAllocator :: impl({
   malloc :: __yo_malloc;
   calloc :: __yo_calloc;
   realloc :: __yo_realloc;
   free :: __yo_free;
   aligned_alloc :: __yo_aligned_alloc;
-
-  export
+  export(
     malloc,
     calloc,
     realloc,
     free,
     aligned_alloc
-  ;
-};
-
-export
+  );
+});
+export(
   size_would_overflow,
   CustomAllocator,
   Allocator,
   Layout,
   layout_of,
   AllocError,
-
   GlobalAllocator
-;
+);

package/std/async.yo

@@ -1,13 +1,9 @@
 //! Async utilities for cooperative task scheduling.
-
 /// Suspend the current async task, allowing other tasks to run on the event loop.
 /// Implemented as an immediately-completing async block that forces a suspension point.
 yield :: (fn(using(io : IO)) -> Impl(Future(unit)))(
-  io.async(()=> {
-    return ();
+  io.async(() => {
+    return(());
   })
 );
-
-export
-  yield
-;
+export(yield);