@ball-lang/compiler 1.6.0 → 1.6.2

package/dist/preamble.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QAk1C/B,CAAC"}
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QAm3C/B,CAAC"}

package/dist/preamble.js

@@ -116,6 +116,10 @@ class BallDouble {
   get isFinite(): boolean { return Number.isFinite(this.value); }
   get isInfinite(): boolean { return !Number.isFinite(this.value) && !Number.isNaN(this.value); }
   get isNegative(): boolean { return this.value < 0 || (this.value === 0 && 1/this.value === -Infinity); }
+  // Mirrors the Number.prototype.remainder polyfill below (truncating
+  // remainder, matching JS % and Dart's num.remainder) — BallDouble wraps
+  // a JS number so it never inherits Number.prototype and needs its own.
+  remainder(other: any): number { return this.value % Number(other); }
   toString(): string {
     const v = this.value;
     if (!isFinite(v)) return v.toString();
@@ -364,6 +368,13 @@ function __ball_bitxor(a: any, b: any): any { return __i64_wrap(__to_bigint(a) ^
 function __ball_bitnot(a: any): any { return __i64_wrap(~__to_bigint(a)); }
 function __ball_shl(a: any, b: any): any { return __i64_wrap(__to_bigint(a) << __to_bigint(b)); }
 function __ball_shr(a: any, b: any): any { return __i64_wrap(__to_bigint(a) >> __to_bigint(b)); }
+// Unsigned/logical shift: reinterpret a as an unsigned 64-bit value (add
+// 2^64 if negative) before shifting, so zeros fill from the left instead of
+// the sign bit — unlike >>> on raw JS numbers, which is only 32-bit.
+function __ball_ushr(a: any, b: any): any {
+  const unsigned = ((__to_bigint(a) % __I64_MOD) + __I64_MOD) % __I64_MOD;
+  return __i64_wrap(unsigned >> __to_bigint(b));
+}
 function __ball_negate(a: any): any {
   if (typeof a === 'bigint') return __i64_wrap(-a);
   if (a instanceof BallDouble) return new BallDouble(-a.value);
@@ -782,6 +793,9 @@ function __ball_cascade(target: any, ops: any[]): any {
   Object.defineProperty(_ballNp, 'isInfinite', {
     configurable: true, get() { const n = Number(this); return n === Infinity || n === -Infinity; },
   });
+  Object.defineProperty(_ballNp, 'isNegative', {
+    configurable: true, get() { const n = Number(this); return n < 0 || (n === 0 && 1 / n === -Infinity); },
+  });
   if (!_ballNp.abs) _ballNp.abs = function () { return Math.abs(Number(this)); };
   if (!_ballNp.ceil) _ballNp.ceil = function () { return Math.ceil(Number(this)); };
   if (!_ballNp.floor) _ballNp.floor = function () { return Math.floor(Number(this)); };
@@ -919,14 +933,33 @@ function __ball_cascade(target: any, ops: any[]): any {
     if (this == null || typeof this !== 'object') return [];
     return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
   });
+  // .keys/.values on a non-Map must FAIL LOUD (throw a catchable error), not
+  // silently return [] — the silent-degradation class of bug that hid issue
+  // #55 (mirrors the fix already applied to the Dart/C++ compilers).
+  //
+  // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
+  // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
+  // object for a primitive receiver (e.g. (42).keys boxes this to a Number
+  // instance) — typeof this is then 'object', not 'number', so a bare
+  // __ball_is_type(this, 'Map') (which only excludes Array/BallDouble/Set)
+  // would wrongly treat a boxed int/string as Map-like. Exclude the wrapper
+  // types explicitly instead of widening the shared type-check.
+  const __isGenuineMap = (v: any) =>
+    typeof v === 'object' && v !== null && !Array.isArray(v) &&
+    !(v instanceof BallDouble) && !(v instanceof Set) &&
+    !(v instanceof Number) && !(v instanceof String) && !(v instanceof Boolean);
   defDartGetter('keys', function (this: any) {
     if (this instanceof Map) return [..._nativeMapKeys.call(this)];
-    if (this == null || typeof this !== 'object') return [];
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .keys getter (not a Map)');
+    }
     return Object.keys(this);
   });
   defDartGetter('values', function (this: any) {
     if (this instanceof Map) return [..._nativeMapValues.call(this)];
-    if (this == null || typeof this !== 'object') return [];
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .values getter (not a Map)');
+    }
     return Object.values(this);
   });
   defDartGetter('length', function (this: any) {

package/dist/preamble.js.map

@@ -1 +1 @@
-{"version":3,"file":"preamble.js","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAk1C5C,CAAC"}
+{"version":3,"file":"preamble.js","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm3C5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ball-lang/compiler",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Ball → TypeScript compiler. Consumes a Ball protobuf Program and emits idiomatic TypeScript via ts-morph. The canonical TS compiler for Ball — lives in TS land so TS syntax knowledge doesn't leak into other languages.",
   "type": "module",
   "main": "dist/index.js",

package/src/compiler.ts

@@ -99,6 +99,19 @@ export class BallCompiler {
    */
   private renameStack: Map<string, string>[] = [];
 
+  /**
+   * Stack of `std.label` names currently enclosing the statement being
+   * compiled (see `emitLabelStmt`/`emitGotoStmt`). A `std.label` lowers to a
+   * labelled `while (true) { ... break name; }`, and a nested `std.goto`
+   * targeting one of these names lowers to `continue name;` — TS (unlike
+   * Dart's `continue` targeting a switch case, or C++'s real `goto`) only
+   * allows `continue`/`break` to target an *enclosing* labelled loop, so this
+   * only supports backward jumps to a label the goto is lexically inside of.
+   * A `goto` to any other name fails loud at compile time (see `emitGotoStmt`)
+   * rather than silently emitting invalid or wrong-behaving TS.
+   */
+  private activeGotoLabels: string[] = [];
+
   constructor(program: Program) {
     this.program = program;
   }
@@ -3138,7 +3151,7 @@ function __isUnknownFnError(e: any): boolean {
     const kinds = new Set([
       "if", "for", "for_in", "for_each", "while", "do_while", "try",
       "return", "break", "continue", "labeled", "throw", "rethrow",
-      "assign", "switch", "switch_expr",
+      "assign", "switch", "switch_expr", "label", "goto",
     ]);
     if (!kinds.has(call.function)) return false;
     // Accept both explicit std module AND empty module (the encoder
@@ -3177,6 +3190,8 @@ function __isUnknownFnError(e: any): boolean {
         if (body) this.emitStatementOrExpression(body, false);
         break;
       }
+      case "label":     this.emitLabelStmt(call); break;
+      case "goto":      this.emitGotoStmt(call); break;
       case "throw": {
         const v = field(call, "value");
         if (v) {
@@ -3417,6 +3432,47 @@ function __isUnknownFnError(e: any): boolean {
     this.writeln(`}`);
   }
 
+  /**
+   * `std.label(name, body)` — a named jump target that `std.goto(label)`
+   * re-enters. TS has no real `goto`, so this lowers to a labelled
+   * `while (true)` loop: running the body once and falling off the end
+   * (the common case, and the only shape a `goto` targeting it can
+   * restart) matches Ball's "run once, or re-run from the top on goto"
+   * semantics, with `break name;` after the body covering the fall-off
+   * case exactly as the Dart compiler's switch-based simulation does.
+   * See `activeGotoLabels` for why only backward jumps are supported.
+   */
+  private emitLabelStmt(call: FunctionCall): void {
+    const name = stringField(call, "name");
+    const body = field(call, "body");
+    if (!name || !body) {
+      throw new Error("std.label requires a string \"name\" and a \"body\"");
+    }
+    this.activeGotoLabels.push(name);
+    this.writeln(`${name}: while (true) {`);
+    this.depth++;
+    this.emitStatementOrExpression(body, false);
+    this.writeln(`break ${name};`);
+    this.depth--;
+    this.writeln(`}`);
+    this.activeGotoLabels.pop();
+  }
+
+  /** `std.goto(label)` — see `emitLabelStmt` and `activeGotoLabels`. */
+  private emitGotoStmt(call: FunctionCall): void {
+    const label = stringField(call, "label");
+    if (!label) throw new Error('std.goto requires a string "label"');
+    if (!this.activeGotoLabels.includes(label)) {
+      throw new Error(
+        `std.goto("${label}") is not inside its own std.label("${label}", ...) body — ` +
+        "the TS compiler only supports goto as a backward jump that restarts an " +
+        "enclosing label (mirrors a labelled loop); forward jumps and jumps to a " +
+        "sibling label are not supported (#226).",
+      );
+    }
+    this.writeln(`continue ${label};`);
+  }
+
   private emitDoWhileStmt(call: FunctionCall): void {
     const cond = field(call, "condition");
     const body = field(call, "body");
@@ -3917,7 +3973,15 @@ function __isUnknownFnError(e: any): boolean {
       this.currentClassName !== undefined &&
       this.currentClassFields.has(fa.field) &&
       !this.currentClassMethodNames.has(fa.field);
-    const obj = isSelfRef || isSuperFieldRef ? "this" : this.expr(fa.object);
+    const rawObj = isSelfRef || isSuperFieldRef ? "this" : this.expr(fa.object);
+    // A bare numeric-literal receiver (e.g. `0`, `-4`, `123n`) parses as the
+    // start of a float literal when immediately followed by `.field` —
+    // `0.isNegative` is `SyntaxError: Identifier cannot follow number`.
+    // Parenthesize whenever the compiled object text IS (not merely
+    // contains) such a token; a double literal already compiles through
+    // `new BallDouble(...)` and a negated int through `__ball_negate(...)`,
+    // so both are already safe — only the bare-token case needs this.
+    const obj = /^-?\d+n?$/.test(rawObj) ? `(${rawObj})` : rawObj;
     const f = fa.field;
     if (f === "length") return `${obj}.length`;
     // Positional record field: `.$1` / `.$2` → [0] / [1].
@@ -4289,7 +4353,7 @@ function __isUnknownFnError(e: any): boolean {
       case "bitwise_not":  return `__ball_bitnot(${this.expr(fg("value", "arg0")!)})`;
       case "left_shift":   return `__ball_shl(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
       case "right_shift":  return `__ball_shr(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
-      case "unsigned_right_shift": return bin(">>>");
+      case "unsigned_right_shift": return `__ball_ushr(${this.expr(fg("left", "value", "arg0")!)}, ${this.expr(fg("right", "other", "arg1")!)})`;
       case "integer_divide":
         return `__ball_divide(${this.expr(f.get("left")!)}, ${this.expr(f.get("right")!)})`;
       case "concat":       return bin("+");
@@ -4998,6 +5062,10 @@ function __isUnknownFnError(e: any): boolean {
           case "list_length": return `${this.expr(f.get("list")!)}.length`;
           case "list_filter": return `${this.expr(f.get("list")!)}.filter(${this.expr(f.get("function") ?? f.get("callback") ?? f.get("value")!)})`;
           case "list_map": return `${this.expr(f.get("list")!)}.map(${this.expr(f.get("function") ?? f.get("callback") ?? f.get("value")!)})`;
+          // No-seed combine (Dart's Iterable.reduce): starts at the first
+          // element, folds from the second; empty list throws (matches JS
+          // Array.prototype.reduce with no initialValue).
+          case "list_reduce": return `${this.expr(f.get("list")!)}.reduce(${this.expr(f.get("function") ?? f.get("callback") ?? f.get("value")!)})`;
           case "list_sort": {
             const l = this.expr(f.get("list")!);
             const cmp = f.get("comparator") ?? f.get("function") ?? f.get("value");

package/src/preamble.ts

@@ -116,6 +116,10 @@ class BallDouble {
   get isFinite(): boolean { return Number.isFinite(this.value); }
   get isInfinite(): boolean { return !Number.isFinite(this.value) && !Number.isNaN(this.value); }
   get isNegative(): boolean { return this.value < 0 || (this.value === 0 && 1/this.value === -Infinity); }
+  // Mirrors the Number.prototype.remainder polyfill below (truncating
+  // remainder, matching JS % and Dart's num.remainder) — BallDouble wraps
+  // a JS number so it never inherits Number.prototype and needs its own.
+  remainder(other: any): number { return this.value % Number(other); }
   toString(): string {
     const v = this.value;
     if (!isFinite(v)) return v.toString();
@@ -364,6 +368,13 @@ function __ball_bitxor(a: any, b: any): any { return __i64_wrap(__to_bigint(a) ^
 function __ball_bitnot(a: any): any { return __i64_wrap(~__to_bigint(a)); }
 function __ball_shl(a: any, b: any): any { return __i64_wrap(__to_bigint(a) << __to_bigint(b)); }
 function __ball_shr(a: any, b: any): any { return __i64_wrap(__to_bigint(a) >> __to_bigint(b)); }
+// Unsigned/logical shift: reinterpret a as an unsigned 64-bit value (add
+// 2^64 if negative) before shifting, so zeros fill from the left instead of
+// the sign bit — unlike >>> on raw JS numbers, which is only 32-bit.
+function __ball_ushr(a: any, b: any): any {
+  const unsigned = ((__to_bigint(a) % __I64_MOD) + __I64_MOD) % __I64_MOD;
+  return __i64_wrap(unsigned >> __to_bigint(b));
+}
 function __ball_negate(a: any): any {
   if (typeof a === 'bigint') return __i64_wrap(-a);
   if (a instanceof BallDouble) return new BallDouble(-a.value);
@@ -782,6 +793,9 @@ function __ball_cascade(target: any, ops: any[]): any {
   Object.defineProperty(_ballNp, 'isInfinite', {
     configurable: true, get() { const n = Number(this); return n === Infinity || n === -Infinity; },
   });
+  Object.defineProperty(_ballNp, 'isNegative', {
+    configurable: true, get() { const n = Number(this); return n < 0 || (n === 0 && 1 / n === -Infinity); },
+  });
   if (!_ballNp.abs) _ballNp.abs = function () { return Math.abs(Number(this)); };
   if (!_ballNp.ceil) _ballNp.ceil = function () { return Math.ceil(Number(this)); };
   if (!_ballNp.floor) _ballNp.floor = function () { return Math.floor(Number(this)); };
@@ -919,14 +933,33 @@ function __ball_cascade(target: any, ops: any[]): any {
     if (this == null || typeof this !== 'object') return [];
     return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
   });
+  // .keys/.values on a non-Map must FAIL LOUD (throw a catchable error), not
+  // silently return [] — the silent-degradation class of bug that hid issue
+  // #55 (mirrors the fix already applied to the Dart/C++ compilers).
+  //
+  // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
+  // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
+  // object for a primitive receiver (e.g. (42).keys boxes this to a Number
+  // instance) — typeof this is then 'object', not 'number', so a bare
+  // __ball_is_type(this, 'Map') (which only excludes Array/BallDouble/Set)
+  // would wrongly treat a boxed int/string as Map-like. Exclude the wrapper
+  // types explicitly instead of widening the shared type-check.
+  const __isGenuineMap = (v: any) =>
+    typeof v === 'object' && v !== null && !Array.isArray(v) &&
+    !(v instanceof BallDouble) && !(v instanceof Set) &&
+    !(v instanceof Number) && !(v instanceof String) && !(v instanceof Boolean);
   defDartGetter('keys', function (this: any) {
     if (this instanceof Map) return [..._nativeMapKeys.call(this)];
-    if (this == null || typeof this !== 'object') return [];
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .keys getter (not a Map)');
+    }
     return Object.keys(this);
   });
   defDartGetter('values', function (this: any) {
     if (this instanceof Map) return [..._nativeMapValues.call(this)];
-    if (this == null || typeof this !== 'object') return [];
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .values getter (not a Map)');
+    }
     return Object.values(this);
   });
   defDartGetter('length', function (this: any) {