@ball-lang/compiler 1.6.1 → 1.6.3

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

package/dist/preamble.js

@@ -110,7 +110,15 @@ class BallObject extends BallMap {
 // (e.g. 42.0 not 42). Used by the compiled Dart engine's _toDouble.
 class BallDouble {
   readonly value: number;
-  constructor(v: number) { this.value = v; }
+  // Collapse nested wrapping (new BallDouble(new BallDouble(x))) down to the
+  // innermost raw number instead of storing a BallDouble-holding-a-BallDouble.
+  // This can legitimately arise now that string_to_double's OWN compiled
+  // form already wraps its result (#222): the self-hosted engine's Dart
+  // source explicitly does BallDouble(double.parse(s)) to make the parse
+  // result double-preserving, which — once double.parse (string_to_double)
+  // started wrapping on its own — would otherwise double-wrap. Unwrapping
+  // here is idempotent for every other caller, since v is a plain number.
+  constructor(v: number) { this.value = v instanceof BallDouble ? v.value : v; }
   valueOf(): number { return this.value; }
   get isNaN(): boolean { return Number.isNaN(this.value); }
   get isFinite(): boolean { return Number.isFinite(this.value); }
@@ -244,6 +252,13 @@ function __ball_to_string(v: any): string {
     }
     return '{' + parts.join(', ') + '}';
   }
+  if (v instanceof Set) {
+    // A Set is a plain object from typeof's perspective (falls through to
+    // the generic branch below, which reads Object.keys — always [] for a
+    // Set's internal slots), so every Set printed as the empty "{}" no
+    // matter its contents until this dedicated case was added (#219).
+    return '{' + [...v].map(__ball_to_string).join(', ') + '}';
+  }
   if (typeof v === 'object' && !Array.isArray(v)) {
     // StringBuffer-like objects
     if (v['__buffer__'] && Array.isArray(v['__buffer__'])) {
@@ -296,10 +311,13 @@ function __ball_to_int(v: any): any {
   return t;
 }
 
-function __ball_parse_double(s: string): number {
+// Returns a BallDouble (not a bare number) so a whole-valued result (e.g.
+// double.parse('7.0')) still prints "7.0", not "7" — JS numbers erase the
+// int/double distinction that the wrapper exists to preserve (#67/#222).
+function __ball_parse_double(s: string): BallDouble {
   const n = parseFloat(s);
   if (Number.isNaN(n)) throw new Error('FormatException: ' + s);
-  return n;
+  return new BallDouble(n);
 }
 
 function __ball_double_to_string(n: number): string {
@@ -307,6 +325,16 @@ function __ball_double_to_string(n: number): string {
   return n.toString();
 }
 
+// num.toStringAsFixed(digits). JS Number.prototype.toFixed drops the sign of
+// -0 (returns "0.00" not "-0.00"); Dart's toStringAsFixed keeps it, matching
+// the -0 handling __ball_to_string/BallDouble.toString already do.
+function __ball_to_fixed(v: any, digits: any): string {
+  const n = Number(v);
+  const s = n.toFixed(digits);
+  if (n === 0 && 1 / n === -Infinity && !s.startsWith('-')) return '-' + s;
+  return s;
+}
+
 // Polymorphic concat / merge used for std.list_concat. The encoder emits
 // list_concat both for Dart list concat AND for Map.addAll(...) (encoded as
 // m = list_concat(m, other)). Arrays concat positionally; plain objects
@@ -805,7 +833,7 @@ function __ball_cascade(target: any, ops: any[]): any {
   if (!_ballNp.toDouble) _ballNp.toDouble = function () { return Number(this); };
   if (!_ballNp.clamp) _ballNp.clamp = function (lo: any, hi: any) { const n = Number(this); return n < lo ? lo : n > hi ? hi : n; };
   if (!_ballNp.compareTo) _ballNp.compareTo = function (other: any) { const a = Number(this), b = Number(other); return a < b ? -1 : a > b ? 1 : 0; };
-  if (!_ballNp.toStringAsFixed) _ballNp.toStringAsFixed = function (digits: any) { return Number(this).toFixed(digits); };
+  if (!_ballNp.toStringAsFixed) _ballNp.toStringAsFixed = function (digits: any) { return __ball_to_fixed(this, digits); };
   if (!_ballNp.remainder) _ballNp.remainder = function (other: any) { return Number(this) % Number(other); };
 
   // Object.prototype polyfills — used by the compiled engine when

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm3C5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+4C5C,CAAC"}

package/package.json

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

@@ -3100,7 +3100,16 @@ function __isUnknownFnError(e: any): boolean {
       const name = this.resolveVarName(rawName);
       // Track this declaration in the current scope.
       this.scopeDeclaredVars.add(name);
-      if (stmt.let.value !== undefined) {
+      // The encoder marks "no initializer" with a reference to the sentinel
+      // name __no_init__ (rather than omitting `value`) — e.g. `int? maybe;`.
+      // Left uncaught, this compiles to `let maybe = __no_init__;`, which
+      // resolves to the runtime preamble's OWN __no_init__ Symbol (used
+      // internally by the compiled self-hosted engine) instead of leaving
+      // `maybe` genuinely undefined, so a later `??=` never fires (#225).
+      // Mirrors the same check already applied to for-loop init bindings
+      // in renderForInit.
+      const isNoInit = stmt.let.value?.reference?.name === "__no_init__";
+      if (stmt.let.value !== undefined && !isNoInit) {
         this.writeln(`${kw} ${name} = ${this.expr(stmt.let.value)};`);
       } else {
         this.writeln(`${kw} ${name};`);
@@ -4592,7 +4601,17 @@ function __isUnknownFnError(e: any): boolean {
             } else if (fd.value) {
               elems.push(fd.value);
             }
-          } else if (fd.name !== "__type_args__" && fd.name !== "__const__") {
+          } else if (
+            // A `<T>{}` empty-typed-set-literal (e.g. `<int>{}`) carries its
+            // type argument as a field literally named "type_args" (the
+            // encoder's current single-word convention, NOT the older
+            // MessageCreation-level "__type_args__" cosmetic marker checked
+            // elsewhere in this file). Excluding only "__type_args__" left
+            // it falling through to this generic branch and being pushed in
+            // as a bogus set ELEMENT (`<int>{}` -> `new Set(['int'])`
+            // instead of an empty Set, #219).
+            fd.name !== "__type_args__" && fd.name !== "__const__" && fd.name !== "type_args"
+          ) {
             elems.push(fd.value);
           }
         }
@@ -5029,7 +5048,11 @@ function __isUnknownFnError(e: any): boolean {
       }
       // Type ops
       case "type_literal": {
-        const v = f.get("value") ?? f.get("name");
+        // The encoder's canonical field is "type" (matches the Dart compiler's
+        // _stringFieldValue(f, 'type')) — a type literal's stored value is
+        // Type.toString() (e.g. 'int', 'List<dynamic>'), so this just needs to
+        // evaluate to that string; == and interpolation follow for free.
+        const v = f.get("type") ?? f.get("value") ?? f.get("name");
         return v ? this.expr(v) : "null";
       }
       default: {
@@ -5099,7 +5122,7 @@ function __isUnknownFnError(e: any): boolean {
           case "to_string_as_fixed": {
             const v = this.expr(fg("value", "arg0")!);
             const d = this.expr(fg("digits", "arg1", "right")!);
-            return `(+(${v})).toFixed(${d})`;
+            return `__ball_to_fixed(${v}, ${d})`;
           }
           // num.{round,floor,ceil,truncate}ToDouble() → double (issue #100).
           // Wrap in BallDouble so a whole result renders `4.0`, not `4`.
@@ -6376,8 +6399,14 @@ function dartInitializerToTs(
     return defaultInitializer(tsType, rawDartType);
   }
   const s = dartInit.trim();
-  // Already a JS-compatible literal: string, number, bool, null, []
-  if (/^(?:null|true|false|'.*'|".*"|-?\d+(?:\.\d+)?|\[\])$/.test(s)) {
+  // Already a JS-compatible literal: string, number, bool, null, list.
+  // A non-empty Dart list literal (e.g. `[10, 20, 30]`) is valid JS array
+  // syntax as-is — this used to only match the EMPTY `[]` case, so a field
+  // like `var widgets = [10, 20, 30];` fell through to defaultInitializer
+  // (which has no type info to fall back on when the field's declared type
+  // was inferred rather than explicit) and silently dropped to no
+  // initializer at all, i.e. undefined/null (#220).
+  if (/^(?:null|true|false|'.*'|".*"|-?\d+(?:\.\d+)?|\[[\s\S]*\])$/.test(s)) {
     return s;
   }
   // Dart `{}` can mean either an empty Map or an empty Set depending

package/src/preamble.ts

@@ -110,7 +110,15 @@ class BallObject extends BallMap {
 // (e.g. 42.0 not 42). Used by the compiled Dart engine's _toDouble.
 class BallDouble {
   readonly value: number;
-  constructor(v: number) { this.value = v; }
+  // Collapse nested wrapping (new BallDouble(new BallDouble(x))) down to the
+  // innermost raw number instead of storing a BallDouble-holding-a-BallDouble.
+  // This can legitimately arise now that string_to_double's OWN compiled
+  // form already wraps its result (#222): the self-hosted engine's Dart
+  // source explicitly does BallDouble(double.parse(s)) to make the parse
+  // result double-preserving, which — once double.parse (string_to_double)
+  // started wrapping on its own — would otherwise double-wrap. Unwrapping
+  // here is idempotent for every other caller, since v is a plain number.
+  constructor(v: number) { this.value = v instanceof BallDouble ? v.value : v; }
   valueOf(): number { return this.value; }
   get isNaN(): boolean { return Number.isNaN(this.value); }
   get isFinite(): boolean { return Number.isFinite(this.value); }
@@ -244,6 +252,13 @@ function __ball_to_string(v: any): string {
     }
     return '{' + parts.join(', ') + '}';
   }
+  if (v instanceof Set) {
+    // A Set is a plain object from typeof's perspective (falls through to
+    // the generic branch below, which reads Object.keys — always [] for a
+    // Set's internal slots), so every Set printed as the empty "{}" no
+    // matter its contents until this dedicated case was added (#219).
+    return '{' + [...v].map(__ball_to_string).join(', ') + '}';
+  }
   if (typeof v === 'object' && !Array.isArray(v)) {
     // StringBuffer-like objects
     if (v['__buffer__'] && Array.isArray(v['__buffer__'])) {
@@ -296,10 +311,13 @@ function __ball_to_int(v: any): any {
   return t;
 }
 
-function __ball_parse_double(s: string): number {
+// Returns a BallDouble (not a bare number) so a whole-valued result (e.g.
+// double.parse('7.0')) still prints "7.0", not "7" — JS numbers erase the
+// int/double distinction that the wrapper exists to preserve (#67/#222).
+function __ball_parse_double(s: string): BallDouble {
   const n = parseFloat(s);
   if (Number.isNaN(n)) throw new Error('FormatException: ' + s);
-  return n;
+  return new BallDouble(n);
 }
 
 function __ball_double_to_string(n: number): string {
@@ -307,6 +325,16 @@ function __ball_double_to_string(n: number): string {
   return n.toString();
 }
 
+// num.toStringAsFixed(digits). JS Number.prototype.toFixed drops the sign of
+// -0 (returns "0.00" not "-0.00"); Dart's toStringAsFixed keeps it, matching
+// the -0 handling __ball_to_string/BallDouble.toString already do.
+function __ball_to_fixed(v: any, digits: any): string {
+  const n = Number(v);
+  const s = n.toFixed(digits);
+  if (n === 0 && 1 / n === -Infinity && !s.startsWith('-')) return '-' + s;
+  return s;
+}
+
 // Polymorphic concat / merge used for std.list_concat. The encoder emits
 // list_concat both for Dart list concat AND for Map.addAll(...) (encoded as
 // m = list_concat(m, other)). Arrays concat positionally; plain objects
@@ -805,7 +833,7 @@ function __ball_cascade(target: any, ops: any[]): any {
   if (!_ballNp.toDouble) _ballNp.toDouble = function () { return Number(this); };
   if (!_ballNp.clamp) _ballNp.clamp = function (lo: any, hi: any) { const n = Number(this); return n < lo ? lo : n > hi ? hi : n; };
   if (!_ballNp.compareTo) _ballNp.compareTo = function (other: any) { const a = Number(this), b = Number(other); return a < b ? -1 : a > b ? 1 : 0; };
-  if (!_ballNp.toStringAsFixed) _ballNp.toStringAsFixed = function (digits: any) { return Number(this).toFixed(digits); };
+  if (!_ballNp.toStringAsFixed) _ballNp.toStringAsFixed = function (digits: any) { return __ball_to_fixed(this, digits); };
   if (!_ballNp.remainder) _ballNp.remainder = function (other: any) { return Number(this) % Number(other); };
 
   // Object.prototype polyfills — used by the compiled engine when