@ball-lang/engine 1.4.2 → 1.4.4

package/src/compiled_engine.ts

@@ -3385,9 +3385,6 @@ export class BallEngine {
         }
       }
     }
-    if (((__ball_eq(name, 'List') || __ball_eq(name, 'Map')) || __ball_eq(name, 'Set'))) {
-      return { ['__class_ref__']: name, ['__type__']: '__builtin_class__' };
-    }
     if (scope.has(name)) {
       let bound = scope.lookup(name);
       if (!__ball_eq(bound, null)) {
@@ -3499,6 +3496,9 @@ export class BallEngine {
       this._globalScope.bind(staticField.fullName, value);
       return value;
     }
+    if (((__ball_eq(name, 'List') || __ball_eq(name, 'Map')) || __ball_eq(name, 'Set'))) {
+      return { ['__class_ref__']: name, ['__type__']: '__builtin_class__' };
+    }
     return scope.lookup(name);
   }
 
@@ -3992,15 +3992,17 @@ export class BallEngine {
         }
         let instanceFields = {};
         let allFieldNames = this._collectAllFieldNames(msg.typeName);
-        for (const fieldName of typeDef.fieldNames) {
-          instanceFields[fieldName] = null;
-        }
         for (const entry of fields.entries) {
           if (!entry.key.startsWith('arg')) {
             instanceFields[entry.key] = entry.value;
           }
         }
         this._initFieldDefaults(msg.typeName, instanceFields);
+        for (const fieldName of typeDef.fieldNames) {
+          if (!(fieldName in instanceFields)) {
+            instanceFields[fieldName] = null;
+          }
+        }
         let ctorEntry = this._lookupConstructor(msg.typeName);
         let resolvedParams = {};
         if ((!__ball_eq(ctorEntry, null) && hasMetadata(ctorEntry.func))) {
@@ -4282,6 +4284,24 @@ export class BallEngine {
     if ((__ball_eq(trimmed, '""') || __ball_eq(trimmed, '\'\''))) {
       return '';
     }
+    if ((((trimmed.length >= 2) && trimmed.startsWith('[')) && trimmed.endsWith(']'))) {
+      let inner = trimmed.substring(1, __ball_sub(trimmed.length, 1)).trim();
+      if ((inner.length === 0)) {
+        return [];
+      }
+      if ((!inner.includes('[') && !inner.includes('{'))) {
+        return [...inner.split(',').map(((s) => {
+          const input = s;
+          return s.trim();
+        })).filter(((s) => {
+          const input = s;
+          return !(s.length === 0);
+        })).map(((s) => {
+          const input = s;
+          return this._parseInitializer(s);
+        }))];
+      }
+    }
     let intVal = int.tryParse(trimmed);
     if (!__ball_eq(intVal, null)) {
       return intVal;
@@ -4290,7 +4310,7 @@ export class BallEngine {
     if (!__ball_eq(doubleVal, null)) {
       return doubleVal;
     }
-    if (((trimmed.startsWith('\'') && trimmed.endsWith('\'')) || (trimmed.startsWith('"') && trimmed.endsWith('"')))) {
+    if (((trimmed.length >= 2) && ((trimmed.startsWith('\'') && trimmed.endsWith('\'')) || (trimmed.startsWith('"') && trimmed.endsWith('"'))))) {
       return trimmed.substring(1, __ball_sub(trimmed.length, 1));
     }
     return trimmed;
@@ -4334,6 +4354,12 @@ export class BallEngine {
           superFields[fname] = __ball_index(childFields, fname);
         }
       }
+      this._initFieldDefaults(superclass, superFields);
+      for (const fname of parentTypeDef.fieldNames) {
+        if (!(fname in superFields)) {
+          superFields[fname] = null;
+        }
+      }
       let parentMethods = this._resolveTypeMethods(qualifiedSuperclass);
       let parentMethodsMap = parentMethods.cast();
       let grandparent = parentTypeDef.superclass;

package/src/engine_setup.ts

@@ -485,8 +485,16 @@ export function createEngineSetup(mod: EngineModule) {
     if (v && typeof v === 'object' && v.__ball_generator__ === true) return __bts(v.values);
     if (Array.isArray(v)) return '[' + v.map(__bts).join(', ') + ']';
     if (v instanceof Map) {
+      // NOT `v.entries()` — the compiled engine's own preamble shadows
+      // `Map.prototype.entries` with a Dart-style GETTER (returning an array
+      // of {key,value} objects, matching Dart's `Map.entries` property) so
+      // Ball's `.entries` field access works. That shadow makes `v.entries`
+      // non-callable, so `v.entries()` throws "not a function" for any real
+      // Map value. Iterate the Map directly instead — a Map's default
+      // iterator already yields [key, value] pairs and is unaffected by the
+      // entries/keys/values property shadowing.
       const parts: string[] = [];
-      for (const [k, val] of v.entries()) parts.push(__bts(k) + ': ' + __bts(val));
+      for (const [k, val] of v) parts.push(__bts(k) + ': ' + __bts(val));
       return '{' + parts.join(', ') + '}';
     }
     if (v instanceof Set) return '{' + [...v].map(__bts).join(', ') + '}';
@@ -906,7 +914,16 @@ export function createEngineSetup(mod: EngineModule) {
     _r('string_char_at', (i: any) => { const m = _m(i); return String(m['value'] ?? m['string'] ?? '').charAt(Number(m['index'] ?? m['arg0'] ?? 0)); });
     _r('string_to_int', (i: any) => {
       const m = _m(i); const s = String(m['value'] ?? m['string'] ?? i ?? '').trim();
-      if (!/^-?\d+$/.test(s)) throw Object.assign(new Error('FormatException: ' + s), { __type__: 'FormatException', message: s });
+      // `.message` must be the bare invalid text (Dart's `FormatException.message`
+      // is never prefixed with the type name — only `.toString()` adds that).
+      // Setting `name: 'FormatException'` (not just a `message` override) lets
+      // the default `Error.prototype.toString()` ("name: message") produce the
+      // Dart-correct "FormatException: <text>" for anything that prints the
+      // caught exception itself rather than `.message`. Previously the message
+      // override clobbered the "FormatException: " prefix right back out,
+      // leaving `.name` as the native "Error" — undetected because no
+      // conformance fixture prints a caught FormatException directly.
+      if (!/^-?\d+$/.test(s)) throw Object.assign(new Error(s), { name: 'FormatException', __type__: 'FormatException' });
       return parseInt(s, 10);
     });
     _r('writeCharCode', (i: any) => { const m = _m(i); const self = m['self']; if (typeof self === 'object' && self !== null) { self['__buffer__'] = (self['__buffer__'] ?? '') + String.fromCharCode(Number(m['arg0'] ?? m['value'] ?? 0)); } return null; });
@@ -965,7 +982,21 @@ export function createEngineSetup(mod: EngineModule) {
       return true;
     });
     _r('concat', (i: any) => { const m = _m(i); return String(m['left'] ?? '') + String(m['right'] ?? ''); });
-    _r('null_check', (i: any) => { const m = _m(i); const v = m['value'] ?? i; if (v == null) throw new Error('Null check operator used on a null value'); return v; });
+    // `?? i` (used by most unary helpers below) can't distinguish "no `value`
+    // field" from "`value` is explicitly null" — for every OTHER helper that's
+    // harmless (a null numeric/string arg just coerces away), but for
+    // null_check it inverts the function's entire purpose: `x!` where `x` is
+    // null must throw (matches the Dart engine's `_extractUnaryArg` + null
+    // check — see engine_std.dart's 'null_check' and its
+    // "throws BallRuntimeError on null" test), yet `m['value'] ?? i` silently
+    // fell back to the (truthy) input map and returned it instead of
+    // throwing. hasOwnProperty-gate so an explicit null is honored.
+    _r('null_check', (i: any) => {
+      const m = _m(i);
+      const v = Object.prototype.hasOwnProperty.call(m, 'value') ? m['value'] : i;
+      if (v == null) throw new Error('Null check operator used on a null value');
+      return v;
+    });
     _r('compare_to', (i: any) => {
       const m = _m(i); const l = m['left'] ?? m['value'] ?? m['self'] ?? m['a'] ?? 0; const r = m['right'] ?? m['other'] ?? m['arg0'] ?? m['b'] ?? 0;
       if (typeof l === 'string' && typeof r === 'string') return l < r ? -1 : l > r ? 1 : 0;