@ball-lang/compiler 1.7.3 → 1.7.5

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,QAq7C/B,CAAC"}
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../src/preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QA29C/B,CAAC"}

package/dist/preamble.js

@@ -994,14 +994,11 @@ function __ball_cascade(target: any, ops: any[]): any {
       },
     });
   }
-  defDartGetter('entries', function (this: any) {
-    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
-    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).
+  // .entries/.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). .entries used to be the odd one out here, silently
+  // returning [] instead of throwing — same bug family as #218.
   //
   // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
   // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
@@ -1014,6 +1011,13 @@ function __ball_cascade(target: any, ops: any[]): 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('entries', function (this: any) {
+    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .entries getter (not a Map)');
+    }
+    return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
+  });
   defDartGetter('keys', function (this: any) {
     if (this instanceof Map) return [..._nativeMapKeys.call(this)];
     if (!__isGenuineMap(this)) {
@@ -1076,6 +1080,40 @@ function __ball_cascade(target: any, ops: any[]): any {
   });
 })();
 
+// std.map_keys/std.map_values/std.map_entries (the base-function-call form,
+// as opposed to the .keys/.values/.entries DART-GETTER-STYLE property
+// access the defDartGetter block above already guards) must ALSO fail loud
+// on a non-Map receiver instead of silently returning [] — same "genuine
+// Map" check, exposed as top-level helpers so compileStdCall's emitted code
+// can call them (#218).
+function __ball_map_keys(m: any): any {
+  if (m instanceof Map) return [...m.keys()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .keys getter (not a Map)');
+  }
+  return Object.keys(m);
+}
+function __ball_map_values(m: any): any {
+  if (m instanceof Map) return [...m.values()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .values getter (not a Map)');
+  }
+  return Object.values(m);
+}
+function __ball_map_entries(m: any): any {
+  if (m instanceof Map) return [...m.entries()].map(([k, v]) => ({ key: k, value: v }));
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .entries getter (not a Map)');
+  }
+  return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
+}
+
 // ── Protobuf Struct/Value compatibility ─────────────────────────
 //
 // Dart's protobuf runtime wraps google.protobuf.Struct as a class

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAq7C5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA29C5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ball-lang/compiler",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "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

@@ -4451,7 +4451,27 @@ function __isUnknownFnError(e: any): boolean {
       case "math_infinity": return "Infinity";
       case "math_nan":      return "NaN";
       case "print":      return `console.log(__ball_to_string(${this.expr(f.get("message")!)}))`;
-      case "index":      return `__ball_index(${this.expr(f.get("target")!)}, ${this.expr(f.get("index")!)})`;
+      case "index": {
+        const target = f.get("target")!;
+        const idx = f.get("index")!;
+        // Bracket-invoking a string-literal-named operator method (e.g.
+        // `a['+'](b)` — the only way to call one, since TS has no `operator`
+        // keyword) indexes with the RAW lexeme, but the compiled class
+        // exposes the operator under its canonical __op_*__ name (#248) —
+        // translate the lexeme so the access finds the real method instead
+        // of a nonexistent literal '+' property (#252). "-" is ambiguous
+        // (unary __op_neg__ vs binary __op_sub__ — a class can only define
+        // ONE '-'-named method, so exactly one of the two properties ever
+        // actually exists; ?? picks whichever it is without needing type
+        // info to disambiguate at the call site).
+        const lexeme = idx.literal?.stringValue;
+        if (lexeme !== undefined && Object.prototype.hasOwnProperty.call(operatorIndexNames, lexeme)) {
+          const targetStr = this.expr(target);
+          if (lexeme === "-") return `(${targetStr}.__op_sub__ ?? ${targetStr}.__op_neg__)`;
+          return `${targetStr}.${operatorIndexNames[lexeme]}`;
+        }
+        return `__ball_index(${this.expr(target)}, ${this.expr(idx)})`;
+      }
       case "null_coalesce": return `(${this.expr(f.get("left")!)} ?? ${this.expr(f.get("right")!)})`;
       case "null_check": return this.expr(f.get("value")!);
       case "is": {
@@ -4941,15 +4961,23 @@ function __isUnknownFnError(e: any): boolean {
       }
       case "map_keys": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.keys(${this.expr(map)})` : "[]";
+        // Fail loud on a non-Map receiver instead of silently returning [] —
+        // that silent degradation is the class of bug that hid issue #55
+        // (mirrors the .keys DART-GETTER guard already installed in
+        // preamble.ts's defDartGetter block, and the engine/C++-compiler
+        // guards for the same base function, #218).
+        return map ? `__ball_map_keys(${this.expr(map)})` : "[]";
       }
       case "map_values": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.values(${this.expr(map)})` : "[]";
+        return map ? `__ball_map_values(${this.expr(map)})` : "[]";
       }
       case "map_entries": {
         const map = f.get("map") ?? f.get("value");
-        return map ? `Object.entries(${this.expr(map)}).map(([k, v]) => ({key: k, value: v}))` : "[]";
+        // Same silent-degradation class as map_keys/map_values (#218): a
+        // bare Object.entries(...) on a non-Map silently returns garbage
+        // instead of failing loud.
+        return map ? `__ball_map_entries(${this.expr(map)})` : "[]";
       }
       case "map_length": {
         const map = f.get("map") ?? f.get("value");
@@ -6493,6 +6521,36 @@ function unwrapLambda(e: Expression): Expression {
   return e;
 }
 
+/** Maps an operator lexeme to the canonical __op_*__ name a compiled class
+ *  exposes it under (mirrors ts/encoder's OPERATOR_CANONICAL_NAMES exactly
+ *  — double-trailing-underscore; NOT sanitize()'s single-underscore
+ *  operatorMap below, which is a separate, legacy short-name convention).
+ *  Used by std."index" to translate `a['+']` (the only way to bracket-
+ *  invoke a string-literal-named operator method) to the real property. */
+const operatorIndexNames: Record<string, string> = {
+  "[]=": "__op_set_index__",
+  "[]": "__op_get_index__",
+  "==": "__op_eq__",
+  "<": "__op_lt__",
+  "<=": "__op_le__",
+  ">": "__op_gt__",
+  ">=": "__op_ge__",
+  "<<": "__op_shl__",
+  ">>": "__op_shr__",
+  ">>>": "__op_ushr__",
+  "+": "__op_add__",
+  "*": "__op_mul__",
+  "/": "__op_div__",
+  "~/": "__op_idiv__",
+  "%": "__op_mod__",
+  "&": "__op_band__",
+  "|": "__op_bor__",
+  "^": "__op_bxor__",
+  "~": "__op_bnot__",
+  // "-" handled specially at the call site (unary vs binary ambiguity).
+  "-": "__op_sub__",
+};
+
 function sanitize(name: string): string {
   let out = name;
   const colon = out.indexOf(":");

package/src/preamble.ts

@@ -994,14 +994,11 @@ function __ball_cascade(target: any, ops: any[]): any {
       },
     });
   }
-  defDartGetter('entries', function (this: any) {
-    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
-    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).
+  // .entries/.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). .entries used to be the odd one out here, silently
+  // returning [] instead of throwing — same bug family as #218.
   //
   // A getter installed on Object.prototype is invoked in "sloppy" (non-strict)
   // script contexts with this auto-boxed to a Number/String/Boolean WRAPPER
@@ -1014,6 +1011,13 @@ function __ball_cascade(target: any, ops: any[]): 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('entries', function (this: any) {
+    if (this instanceof Map) return [..._nativeMapEntries.call(this)].map(([k, v]: any) => ({ key: k, value: v }));
+    if (!__isGenuineMap(this)) {
+      throw new Error('type \'' + __ball_to_string(this) + '\' has no .entries getter (not a Map)');
+    }
+    return Object.entries(this).map(([k, v]: any) => ({ key: k, value: v }));
+  });
   defDartGetter('keys', function (this: any) {
     if (this instanceof Map) return [..._nativeMapKeys.call(this)];
     if (!__isGenuineMap(this)) {
@@ -1076,6 +1080,40 @@ function __ball_cascade(target: any, ops: any[]): any {
   });
 })();
 
+// std.map_keys/std.map_values/std.map_entries (the base-function-call form,
+// as opposed to the .keys/.values/.entries DART-GETTER-STYLE property
+// access the defDartGetter block above already guards) must ALSO fail loud
+// on a non-Map receiver instead of silently returning [] — same "genuine
+// Map" check, exposed as top-level helpers so compileStdCall's emitted code
+// can call them (#218).
+function __ball_map_keys(m: any): any {
+  if (m instanceof Map) return [...m.keys()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .keys getter (not a Map)');
+  }
+  return Object.keys(m);
+}
+function __ball_map_values(m: any): any {
+  if (m instanceof Map) return [...m.values()];
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .values getter (not a Map)');
+  }
+  return Object.values(m);
+}
+function __ball_map_entries(m: any): any {
+  if (m instanceof Map) return [...m.entries()].map(([k, v]) => ({ key: k, value: v }));
+  if (typeof m !== 'object' || m === null || Array.isArray(m) ||
+      m instanceof BallDouble || m instanceof Set ||
+      m instanceof Number || m instanceof String || m instanceof Boolean) {
+    throw new Error('type \'' + __ball_to_string(m) + '\' has no .entries getter (not a Map)');
+  }
+  return Object.entries(m).map(([k, v]) => ({ key: k, value: v }));
+}
+
 // ── Protobuf Struct/Value compatibility ─────────────────────────
 //
 // Dart's protobuf runtime wraps google.protobuf.Struct as a class