@shd101wyy/yo 0.1.27 → 0.1.29

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "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/async.yo

@@ -1,7 +1,7 @@
 //! 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)))(
+yield :: (fn(io : IO) -> Impl(Future(unit)))(
   io.async(() => {
     return(());
   })

package/std/crypto/random.yo

@@ -54,7 +54,7 @@ extern(
 // ============================================================================
 // Fill a buffer with cryptographically secure random bytes.
 // ============================================================================
-random_bytes :: (fn(buf : *(u8), size : usize, using(exn : Exception)) -> unit)(
+random_bytes :: (fn(buf : *(u8), size : usize, exn : Exception) -> unit)(
   cond(
     (platform == Platform.Macos) => {
       __yo_arc4random_buf(buf, size);
@@ -104,7 +104,7 @@ export(random_bytes);
 // ============================================================================
 // Typed helpers
 // ============================================================================
-random_u32 :: (fn(using(exn : Exception)) -> u32)({
+random_u32 :: (fn(exn : Exception) -> u32)({
   buf := Array(u8, usize(4)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
   random_bytes(buf_ptr, usize(4));
@@ -113,16 +113,16 @@ random_u32 :: (fn(using(exn : Exception)) -> u32)({
       (u32(buf(usize(2))) << u32(16)) |
         (u32(buf(usize(3))) << u32(24))
       });
-random_u64 :: (fn(using(exn : Exception)) -> u64)({
+random_u64 :: (fn(exn : Exception) -> u64)({
   lo := u64(random_u32());
   hi := u64(random_u32());
   lo | (hi << u64(32))
 });
-random_f64 :: (fn(using(exn : Exception)) -> f64)(
+random_f64 :: (fn(exn : Exception) -> f64)(
   f64(random_u64()) / f64(18446744073709551615.0)
 );
 // Return a random integer in the half-open range [min, max).
-random_range :: (fn(min : i64, max : i64, using(exn : Exception)) -> i64)({
+random_range :: (fn(min : i64, max : i64, exn : Exception) -> i64)({
   span := (max - min);
   cond(
     (span <= i64(0)) => min,
@@ -137,7 +137,7 @@ export(random_u32, random_u64, random_f64, random_range);
 // UUID v4
 // ============================================================================
 // Generate a random UUID v4 string: "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
-uuid_v4 :: (fn(using(exn : Exception)) -> String)({
+uuid_v4 :: (fn(exn : Exception) -> String)({
   bytes := ArrayList(u8).with_capacity(usize(16));
   buf := Array(u8, usize(16)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));

package/std/encoding/base64.yo

@@ -64,7 +64,7 @@ export(base64_encode, base64_encode_url);
 // ============================================================================
 // Decoding
 // ============================================================================
-_decode_char :: (fn(c : u8, alpha : str, using(exn : Exception)) -> u8)({
+_decode_char :: (fn(c : u8, alpha : str, exn : Exception) -> u8)({
   i := usize(0);
   while(i < usize(64), i = (i + usize(1)), {
     cond(
@@ -76,7 +76,7 @@ _decode_char :: (fn(c : u8, alpha : str, using(exn : Exception)) -> u8)({
   });
   exn.throw(dyn(EncodingError.InvalidChar(c)))
 });
-_decode_with :: (fn(s : str, alpha : str, using(exn : Exception)) -> ArrayList(u8))({
+_decode_with :: (fn(s : str, alpha : str, exn : Exception) -> ArrayList(u8))({
   // Strip trailing padding
   len := s.len();
   while((len > usize(0)) && (s.bytes(len - usize(1)) == _PAD), len = (len - usize(1)), ());
@@ -107,11 +107,11 @@ _decode_with :: (fn(s : str, alpha : str, using(exn : Exception)) -> ArrayList(u
   out
 });
 /// Decode a standard base64 string to bytes. Throws via `Exception` on invalid input.
-base64_decode :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))(
+base64_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
   _decode_with(s, _STD_ALPHA)
 );
 /// Decode a URL-safe base64 string to bytes. Throws via `Exception` on invalid input.
-base64_decode_url :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))(
+base64_decode_url :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
   _decode_with(s, _URL_ALPHA)
 );
 export(base64_decode, base64_decode_url);

package/std/encoding/hex.yo

@@ -64,7 +64,7 @@ export(hex_encode);
 // ============================================================================
 // Decoding
 // ============================================================================
-_hex_nibble :: (fn(c : u8, using(exn : Exception)) -> u8)(
+_hex_nibble :: (fn(c : u8, exn : Exception) -> u8)(
   cond(
     ((c >= u8(48)) && (c <= u8(57))) => (c - u8(48)),
     // '0'-'9'
@@ -76,7 +76,7 @@ _hex_nibble :: (fn(c : u8, using(exn : Exception)) -> u8)(
   )
 );
 /// Decode a hexadecimal string to bytes. Throws via `Exception` on invalid input.
-hex_decode :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))({
+hex_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))({
   cond(
     ((s.len() % usize(2)) != usize(0)) => {
       exn.throw(dyn(EncodingError.OddLength));

package/std/encoding/json.yo

@@ -8,7 +8,7 @@
 //! { json_parse, json_stringify, JsonValue } :: import "std/encoding/json";
 //! { Exception } :: import "std/error";
 //!
-//! given(exn) := Exception(throw : ((err) -> { escape (); }));
+//! exn := Exception(throw : ((err) -> { unwind (); }));
 //! v := json_parse(`{"x": 1}`);
 //! println(json_stringify(v));
 //! ```
@@ -30,7 +30,7 @@ JsonError :: enum(
   InvalidNumber,
   /// Invalid escape sequence in a string.
   InvalidEscape,
-  /// Invalid Unicode escape in a string.
+  /// Invalid Unicode unwind in a string.
   InvalidUnicode,
   /// Other error with a descriptive message.
   Other(msg : String)
@@ -553,7 +553,7 @@ _parse_value :: (fn(p : _Parser) -> Result(JsonValue, JsonError))({
 // Public API
 // ============================================================================
 /// Parse a JSON string into a `JsonValue` tree. Throws via `Exception` on invalid input.
-json_parse :: (fn(s : str, using(exn : Exception)) -> JsonValue)({
+json_parse :: (fn(s : str, exn : Exception) -> JsonValue)({
   p := _Parser.new(s);
   match(
     _parse_value(p),

package/std/encoding/utf16.yo

@@ -68,7 +68,7 @@ export(utf8_to_utf16);
 ///
 /// Decodes surrogate pairs back into supplementary code points.
 /// Throws via `Exception` on unpaired surrogates.
-utf16_to_utf8 :: (fn(data : ArrayList(u16), using(exn : Exception)) -> String)({
+utf16_to_utf8 :: (fn(data : ArrayList(u16), exn : Exception) -> String)({
   out := ArrayList(u8).new();
   i := usize(0);
   while(i < data.len(), {

package/std/error.yo

@@ -15,15 +15,27 @@ export(AnyError);
 impl(String, Error());
 /// Non-resumable exception handling effect record.
 /// Use `throw` to raise an `AnyError` and abort the current computation.
+/// `throw` is `ctl(...)` — handler body may contain `unwind`, and the
+/// handler value is frame-bound (see plans/EXPLICIT_EFFECTS.md §4).
 Exception :: struct(
-  throw : (fn(forall(ResumeType : Type), error : AnyError) -> ResumeType)
+  throw : (ctl(forall(ResumeType : Type), error : AnyError) -> ResumeType)
 );
 export(Exception);
 /// Creates a resumable exception effect record parameterized by the resume type.
 /// Unlike `Exception`, the handler can return a value to resume the computation.
+/// `throw` is still `ctl(...)` because the handler MAY choose to unwind;
+/// regular `fn` returns are also valid via subtyping `fn <: ctl`.
 ResumableException :: (fn(comptime(ResumeType) : Type) -> comptime(Type))(
   struct(
-    throw : (fn(error : AnyError) -> ResumeType)
+    throw : (ctl(error : AnyError) -> ResumeType)
   )
 );
 export(ResumableException);
+/// Common effect bundle: IO + Exception.
+/// Used as the effect parameter for Futures that perform IO and may throw.
+/// Construct with `{ io, exn }`; project with `e.io` or `e.exn`.
+IOErr :: struct(
+  io : IO,
+  exn : Exception
+);
+export(IOErr);