porffor 0.55.17 → 0.55.19

package/compiler/builtins/__internal_object.ts

@@ -8,8 +8,7 @@ export const __Porffor_object_underlying = (obj: any): any => {
     t >= Porffor.TYPES.error,
     t <= Porffor.TYPES.todoerror
   )) {
-    const remap: object = obj;
-    return remap;
+    return obj as object;
   }
 
   if (Porffor.fastAnd(t > 0x05, t != Porffor.TYPES.undefined)) {
@@ -36,41 +35,38 @@ export const __Porffor_object_underlying = (obj: any): any => {
       }
 
       if (t == Porffor.TYPES.array) {
-        const arr: any[] = obj;
-        const len: i32 = arr.length;
+        const len: i32 = (obj as any[]).length;
 
         const key5: bytestring = 'length';
         __Porffor_object_expr_initWithFlags(underlying, key5, len, 0b1000);
 
         // todo: this should somehow be kept in sync?
         for (let i: i32 = 0; i < len; i++) {
-          __Porffor_object_expr_initWithFlags(underlying, __Number_prototype_toString(i), arr[i], 0b1110);
+          __Porffor_object_expr_initWithFlags(underlying, __Number_prototype_toString(i), (obj as any[])[i], 0b1110);
         }
       }
 
       if (Porffor.fastOr(t == Porffor.TYPES.string, t == Porffor.TYPES.stringobject)) {
-        const str: string = obj;
-        const len: i32 = str.length;
+        const len: i32 = (obj as string).length;
 
         const key6: bytestring = 'length';
         __Porffor_object_expr_initWithFlags(underlying, key6, len, 0b0000);
 
         for (let i: i32 = 0; i < len; i++) {
-          __Porffor_object_expr_initWithFlags(underlying, __Number_prototype_toString(i), str[i], 0b0100);
+          __Porffor_object_expr_initWithFlags(underlying, __Number_prototype_toString(i), (obj as string)[i], 0b0100);
         }
 
         if (t == Porffor.TYPES.string) Porffor.object.preventExtensions(underlying);
       }
 
       if (t == Porffor.TYPES.bytestring) {
-        const str: bytestring = obj;
-        const len: i32 = str.length;
+        const len: i32 = (obj as bytestring).length;
 
         const key7: bytestring = 'length';
         __Porffor_object_expr_initWithFlags(underlying, key7, len, 0b0000);
 
         for (let i: i32 = 0; i < len; i++) {
-          __Porffor_object_expr_initWithFlags(underlying, __Number_prototype_toString(i), str[i], 0b0100);
+          __Porffor_object_expr_initWithFlags(underlying, __Number_prototype_toString(i), (obj as bytestring)[i], 0b0100);
         }
 
         Porffor.object.preventExtensions(underlying);

package/compiler/builtins/__internal_string.ts

@@ -54,7 +54,6 @@ if 64
     v128.any_true
     if 64
       i32.const 0
-      i32.const 2
       return
     end
 
@@ -87,7 +86,6 @@ if 64
     i64.ne
     if 64
       i32.const 0
-      i32.const 2
       return
     end
 
@@ -120,7 +118,6 @@ if 64
     i32.ne
     if 64
       i32.const 0
-      i32.const 2
       return
     end
 
@@ -200,7 +197,6 @@ if 64
     v128.any_true
     if 64
       i32.const 0
-      i32.const 2
       return
     end
 
@@ -233,7 +229,6 @@ if 64
     i64.ne
     if 64
       i32.const 0
-      i32.const 2
       return
     end
 
@@ -266,7 +261,6 @@ if 64
     i32.ne
     if 64
       i32.const 0
-      i32.const 2
       return
     end
 

package/compiler/builtins/_internal_object.ts

@@ -92,13 +92,11 @@ i64.shl
 local.get ${get}
 i64.extend_i32_u
 i64.or
-
 f64.reinterpret_i64
-i32.const 1
 return`;
 };
 
-export const __Porffor_object_accessorGet = (entryPtr: i32): Function => {
+export const __Porffor_object_accessorGet = (entryPtr: i32): Function|undefined => {
   const out: Function = Porffor.wasm.i32.load(entryPtr, 0, 4);
 
   // no getter, return undefined
@@ -109,7 +107,7 @@ export const __Porffor_object_accessorGet = (entryPtr: i32): Function => {
   return out;
 };
 
-export const __Porffor_object_accessorSet = (entryPtr: i32): Function => {
+export const __Porffor_object_accessorSet = (entryPtr: i32): Function|undefined => {
   const out: Function = Porffor.wasm.i32.load(entryPtr, 0, 8);
 
   // no setter, return undefined
@@ -137,7 +135,6 @@ export const __Porffor_object_lookup = (obj: any, target: any): i32 => {
 
   let out: boolean = false;
   if (targetType == Porffor.TYPES.symbol) {
-    const targetSym: symbol = target;
     for (; ptr < endPtr; ptr += 14) {
       const keyRaw: i32 = Porffor.wasm.i32.load(ptr, 0, 0);
       if (keyRaw == 0) {
@@ -145,9 +142,9 @@ export const __Porffor_object_lookup = (obj: any, target: any): i32 => {
         out = true;
       }
 
-      if (keyRaw >>> 30 == 3) { // MSB 1 and 2 set, symbol
-        const keySym: symbol = keyRaw & 0x3FFFFFFF; // unset MSB
-        if (keySym == targetSym) return ptr;
+      if (keyRaw >>> 30 == 3) { // MSB 1 and 2 set, symbol (unset MSB x2)
+        // todo: remove casts once weird bug which breaks unrelated things is fixed (https://github.com/CanadaHonk/porffor/commit/5747f0c1f3a4af95283ebef175cdacb21e332a52)
+        if ((keyRaw & 0x3FFFFFFF) as symbol == target as symbol) return ptr;
       }
     }
   } else {
@@ -161,12 +158,10 @@ export const __Porffor_object_lookup = (obj: any, target: any): i32 => {
       const msb: i32 = keyRaw >>> 30;
       if (msb == 0) {
         // bytestring
-        const keyStr: bytestring = keyRaw;
-        if (Porffor.strcmp(keyStr, target)) return ptr;
+        if (Porffor.strcmp(keyRaw as bytestring, target)) return ptr;
       } else if (msb == 2) {
-        // string
-        const keyStr: string = keyRaw & 0x7FFFFFFF; // unset MSB
-        if (Porffor.strcmp(keyStr, target)) return ptr;
+        // string (unset MSB)
+        if (Porffor.strcmp((keyRaw & 0x7FFFFFFF) as string, target)) return ptr;
       }
     }
   }
@@ -497,8 +492,6 @@ local.get ${value}
 local.get ${value+1}
 
 call __Object_is
-drop
-
 i32.trunc_sat_f64_u
 i32.eqz
 local.set ${err}`;

package/compiler/builtins/_internal_string.ts

@@ -35,7 +35,7 @@ export const __Porffor_compareStrings = (a: any, b: any): boolean => {
   return Porffor.strcmp(a, b);
 };
 
-export const __Porffor_concatStrings = (a: any, b: any): boolean => {
+export const __Porffor_concatStrings = (a: any, b: any): any => {
   let at: i32 = Porffor.rawType(a);
   let bt: i32 = Porffor.rawType(b);
 

package/compiler/builtins/array.ts

@@ -66,15 +66,13 @@ export const __Array_from = (arg: any, mapFn: any): any[] => {
   }
 
   if (type == Porffor.TYPES.object) {
-    const obj: object = arg;
-
     const lengthKey: bytestring = 'length';
-    len = ecma262.ToIntegerOrInfinity(obj[lengthKey]);
+    len = ecma262.ToIntegerOrInfinity((arg as object)[lengthKey]);
     if (len > 4294967295) throw new RangeError('Invalid array length');
     if (len < 0) len = 0;
 
     for (let i: i32 = 0; i < len; i++) {
-      out[i] = obj[i];
+      out[i] = (arg as object)[i];
     }
   }
 

package/compiler/builtins/bigint.ts

@@ -6,21 +6,42 @@ export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): b
   if (len > 16383) throw new RangeError('Maximum BigInt size exceeded'); // (65536 - 4) / 4
 
   // const ptr: i32 = Porffor.allocate();
-  const ptr: i32 = Porffor.wasm`local.get ${digits}`;
+  let ptr: i32 = Porffor.wasm`local.get ${digits}`;
 
   Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0);
   Porffor.wasm.i32.store16(ptr, len, 0, 2);
 
+  let allZero: boolean = true;
   for (let i: i32 = 0; i < len; i++) {
-    Porffor.wasm.i32.store(ptr + i * 4, digits[i], 0, 4);
+    const d: i32 = digits[i];
+    if (d != 0) allZero = false;
+
+    Porffor.wasm.i32.store(ptr + i * 4, d, 0, 4);
   }
 
-  const out: bigint = ptr;
-  return out;
+  if (allZero) {
+    // todo: free ptr
+    ptr = 0;
+  }
+
+  return (ptr + 0x8000000000000) as bigint;
 };
 
+// store small (abs(n) < 2^51 (0x8000000000000)) values inline (no allocation)
+// like a ~s52 (s53 exc 2^51+(0-2^32) for u32 as pointer) inside a f64
+export const __Porffor_bigint_inlineToDigitForm = (n: number): number => {
+  const ptr: i32 = Porffor.allocateBytes(4); // 4 meta + 1 digit
+  Porffor.wasm.i32.store8(ptr, n < 0, 0, 0);
+  Porffor.wasm.i32.store16(ptr, 1, 0, 2);
+  Porffor.wasm.i32.store(ptr, Math.abs(n), 0, 4);
+
+  return ptr;
+};
+
+
 export const __Porffor_bigint_fromNumber = (n: number): bigint => {
-  if (!Number.isInteger(n) || !Number.isFinite(n)) throw new RangeError('Cannot convert non-integer to BigInt');
+  if (!Number.isInteger(n) || !Number.isFinite(n)) throw new RangeError('Cannot use non-integer as BigInt');
+  if (Math.abs(n) < 0x8000000000000) return n as bigint;
 
   const negative: boolean = n < 0;
   n = Math.abs(n);
@@ -34,13 +55,16 @@ export const __Porffor_bigint_fromNumber = (n: number): bigint => {
   return __Porffor_bigint_fromDigits(negative, digits);
 };
 
-export const __Porffor_bigint_toNumber = (ptr: i32): number => {
-  const negative: boolean = Porffor.wasm.i32.load8_u(ptr, 0, 0) != 0;
-  const len: i32 = Porffor.wasm.i32.load16_u(ptr, 0, 2);
+export const __Porffor_bigint_toNumber = (x: number): number => {
+  if (Math.abs(x) < 0x8000000000000) return x as number;
+  x -= 0x8000000000000;
+
+  const negative: boolean = Porffor.wasm.i32.load8_u(x, 0, 0) != 0;
+  const len: i32 = Porffor.wasm.i32.load16_u(x, 0, 2);
 
   let out: number = 0;
   for (let i: i32 = 0; i < len; i++) {
-    const d: i32 = Porffor.wasm.i32.load(ptr + i * 4, 0, 4);
+    const d: i32 = Porffor.wasm.i32.load(x + i * 4, 0, 4);
     out = out * 0x100000000 + d;
   }
 
@@ -71,38 +95,61 @@ export const __Porffor_bigint_fromString = (n: string|bytestring): bigint => {
   // 9007199254740994 -> [ 2097152, 2 ]
   // 9007199254740995 -> [ 2097152, 3 ]
 
-  const digits: i32[] = Porffor.allocate();
-
-  const base = 0x100000000; // 2^32
+  let acc: number = 0;
+  let digits: i32[];
+  const BASE: i32 = 0x100000000; // 2^32
 
   for (let i: i32 = end; i < len; i++) {
     const char: i32 = n.charCodeAt(i);
     const digit: i32 = char - 48;
-    if (digit < 0 || digit > 9) throw new SyntaxError('Invalid characters in BigInt string');
-
-    // Multiply current digits by 10 and add the new digit
-    let carry: i32 = digit;
-    for (let j: i32 = 0; j < digits.length; j++) {
-      const value: i32 = digits[j] * 10 + carry;
-      digits[j] = value % base;
-      carry = Math.trunc(value / base);
-    }
+    if (digit < 0 || digit > 9) throw new SyntaxError('Invalid character in BigInt string');
+
+    if (acc == -1) {
+      let carry: i32 = digit;
+      for (let j: i32 = 0; j < digits.length; j++) {
+        const value: i32 = digits[j] * BASE + carry;
+        digits[j] = value % BASE;
+        carry = Math.trunc(value / BASE);
+      }
 
-    // If there's a carry left, push it as a new digit
-    if (carry > 0) {
-      digits.push(carry);
+      if (carry > 0) digits.push(carry);
+    } else {
+      acc = acc * 10 + digit;
+      if (acc >= BASE) {
+        digits = Porffor.allocate();
+        digits.length = 2;
+        digits[0] = Math.floor(acc / BASE);
+        digits[1] = acc % BASE;
+        acc = -1;
+      }
     }
   }
 
-  return __Porffor_bigint_fromDigits(negative, digits);
+  if (acc == -1) return __Porffor_bigint_fromDigits(negative, digits);
+  return (negative ? -acc : acc) as bigint;
 };
 
-export const __Porffor_bigint_toString = (ptr: i32, radix: number): string => {
-  // todo
-  // return '';
+export const __Porffor_bigint_toString = (x: number, radix: any): string => {
+  // todo: actually use bigint
+  return __Number_prototype_toFixed(__Porffor_bigint_toNumber(x), radix);
 };
 
-export const __Porffor_bigint_add = (a: i32, b: i32, sub: boolean): bigint => {
+// todo: hook up all funcs below to codegen
+export const __Porffor_bigint_add = (a: number, b: number, sub: boolean): bigint => {
+  if (Math.abs(a) < 0x8000000000000) {
+    if (Math.abs(b) < 0x8000000000000) {
+      if (sub) b = -b;
+      return __Porffor_bigint_fromNumber(Math.trunc(a + b));
+    }
+
+    a = __Porffor_bigint_inlineToDigitForm(a);
+  } else if (Math.abs(b) < 0x8000000000000) {
+    b = __Porffor_bigint_inlineToDigitForm(b);
+  }
+
+  a -= 0x8000000000000;
+  b -= 0x8000000000000;
+
   const aNegative: boolean = Porffor.wasm.i32.load8_u(a, 0, 0) != 0;
   const aLen: i32 = Porffor.wasm.i32.load16_u(a, 0, 2);
 
@@ -191,22 +238,18 @@ export const __Porffor_bigint_sub = (a: i32, b: i32): bigint => {
 
 export const __Porffor_bigint_mul = (a: i32, b: i32): bigint => {
   // todo
-  // return 0n;
 };
 
 export const __Porffor_bigint_div = (a: i32, b: i32): bigint => {
   // todo
-  // return 0n;
 };
 
 export const __Porffor_bigint_rem = (a: i32, b: i32): bigint => {
   // todo
-  // return 0n;
 };
 
 export const __Porffor_bigint_eq = (a: i32, b: i32): boolean => {
   // todo
-  // return false;
 };
 
 export const __Porffor_bigint_ne = (a: i32, b: i32): boolean => {
@@ -215,12 +258,10 @@ export const __Porffor_bigint_ne = (a: i32, b: i32): boolean => {
 
 export const __Porffor_bigint_gt = (a: i32, b: i32): boolean => {
   // todo
-  // return false;
 };
 
 export const __Porffor_bigint_ge = (a: i32, b: i32): boolean => {
   // todo
-  // return false;
 };
 
 export const __Porffor_bigint_lt = (a: i32, b: i32): boolean => {
@@ -231,3 +272,58 @@ export const __Porffor_bigint_le = (a: i32, b: i32): boolean => {
   return !__Porffor_bigint_gt(a, b);
 };
 
+// 7.1.13 ToBigInt (argument)
+// https://tc39.es/ecma262/#sec-tobigint
+export const __ecma262_ToBigInt = (argument: any): bigint => {
+  // 1. Let prim be ? ToPrimitive(argument, number).
+  const prim: any = ecma262.ToPrimitive.Number(argument);
+
+  // 2. Return the value that prim corresponds to in Table 12.
+  // Table 12: BigInt Conversions
+  // Argument Type 	Result
+  // BigInt 	Return prim.
+  if (Porffor.rawType(prim) == Porffor.TYPES.bigint) return prim;
+
+  // String
+  //     1. Let n be StringToBigInt(prim).
+  //     2. If n is undefined, throw a SyntaxError exception.
+  //     3. Return n.
+  if ((Porffor.rawType(prim) | 0b10000000) == Porffor.TYPES.bytestring) return __Porffor_bigint_fromString(prim);
+
+  // Boolean 	Return 1n if prim is true and 0n if prim is false.
+  if (Porffor.rawType(prim) == Porffor.TYPES.boolean) return prim ? 1n : 0n;
+
+  // Number 	Throw a TypeError exception.
+  // Symbol 	Throw a TypeError exception.
+  // Undefined 	Throw a TypeError exception.
+  // Null 	Throw a TypeError exception.
+  throw new TypeError('Cannot convert to BigInt');
+};
+
+// 21.2.1.1 BigInt (value)
+// https://tc39.es/ecma262/#sec-bigint-constructor-number-value
+export const BigInt = (value: any): bigint => {
+  // 1. If NewTarget is not undefined, throw a TypeError exception.
+  // 2. Let prim be ? ToPrimitive(value, number).
+  const prim: any = ecma262.ToPrimitive.Number(value);
+
+  // 3. If prim is a Number, return ? NumberToBigInt(prim).
+  if (Porffor.rawType(prim) == Porffor.TYPES.number) return __Porffor_bigint_fromNumber(prim);
+
+  // 4. Otherwise, return ? ToBigInt(prim).
+  return __ecma262_ToBigInt(prim);
+};
+
+export const __BigInt_prototype_toString = (_this: bigint, radix: any) => {
+  return __Porffor_bigint_toString(_this, radix);
+};
+
+export const __BigInt_prototype_toLocaleString = (_this: bigint) => {
+  return __Porffor_bigint_toString(_this, 10);
+};
+
+export const __BigInt_prototype_valueOf = (_this: bigint) => {
+  return _this;
+};
+
+// todo: asIntN, asUintN

package/compiler/builtins/boolean.ts

@@ -9,8 +9,7 @@ export const Boolean = function (value: any): boolean|BooleanObject {
   // 2. If NewTarget is undefined, return b.
   if (!new.target) return b;
 
-  const O: BooleanObject = b;
-  return O;
+  return b as BooleanObject;
 };
 
 // 20.3.3.2 Boolean.prototype.toString ()

package/compiler/builtins/generator.ts

@@ -1,8 +1,7 @@
 import type {} from './porffor.d.ts';
 
 export const __Porffor_Generator = (values: any[]): __Porffor_Generator => {
-  const gen: __Porffor_Generator = values;
-  return gen;
+  return values as __Porffor_Generator;
 };
 
 export const __Porffor_Generator_yield = (vals: any[], value: any): void => {
@@ -16,11 +15,10 @@ export const __Porffor_Generator_return = (vals: any[], value: any): __Porffor_G
   vals.length = 1;
   vals[0] = value;
 
-  const gen: __Porffor_Generator = vals;
-  return gen;
+  return vals as __Porffor_Generator;
 };
 
-export const __Porffor_Generator_prototype_next = (vals: any[]): object => {
+export const __Porffor_Generator_prototype_next = (vals: any[]) => {
   const obj: object = {};
   obj.value = vals.shift();
   obj.done = vals.length == 0;
@@ -28,22 +26,21 @@ export const __Porffor_Generator_prototype_next = (vals: any[]): object => {
   return obj;
 };
 
-export const __Porffor_Generator_prototype_return = (vals: any[], value: any): object => {
+export const __Porffor_Generator_prototype_return = (vals: any[], value: any) => {
   vals.length = 1;
   vals[0] = value;
 
   return __Porffor_Generator_prototype_next(vals);
 };
 
-export const __Porffor_Generator_prototype_throw = (vals: any[], value: any): object => {
+export const __Porffor_Generator_prototype_throw = (vals: any[], value: any) => {
   vals.length = 0;
   throw value;
 };
 
 
 export const __Porffor_AsyncGenerator = (values: any[]): __Porffor_AsyncGenerator => {
-  const gen: __Porffor_AsyncGenerator = values;
-  return gen;
+  return values as __Porffor_AsyncGenerator;
 };
 
 export const __Porffor_AsyncGenerator_yield = (vals: any[], value: any): void => {
@@ -57,11 +54,10 @@ export const __Porffor_AsyncGenerator_return = (vals: any[], value: any): __Porf
   vals.length = 1;
   vals[0] = value;
 
-  const gen: __Porffor_AsyncGenerator = vals;
-  return gen;
+  return vals as __Porffor_AsyncGenerator;
 };
 
-export const __Porffor_AsyncGenerator_prototype_next = async (vals: any[]): object => {
+export const __Porffor_AsyncGenerator_prototype_next = async (vals: any[]) => {
   const obj: object = {};
   obj.value = await vals.shift();
   obj.done = vals.length == 0;
@@ -69,14 +65,14 @@ export const __Porffor_AsyncGenerator_prototype_next = async (vals: any[]): obje
   return obj;
 };
 
-export const __Porffor_AsyncGenerator_prototype_return = async (vals: any[], value: any): object => {
+export const __Porffor_AsyncGenerator_prototype_return = async (vals: any[], value: any) => {
   vals.length = 1;
   vals[0] = await value;
 
   return await __Porffor_AsyncGenerator_prototype_next(vals);
 };
 
-export const __Porffor_AsyncGenerator_prototype_throw = async (vals: any[], value: any): object => {
+export const __Porffor_AsyncGenerator_prototype_throw = async (vals: any[], value: any) => {
   vals.length = 0;
   throw await value;
 };

package/compiler/builtins/json.ts

@@ -85,8 +85,7 @@ export const __Porffor_json_serialize = (value: any, depth: i32, space: bytestri
     const hasSpace: boolean = space !== undefined;
     depth += 1;
 
-    const arr: any[] = value;
-    for (const x of arr) {
+    for (const x of (value as any[])) {
       if (hasSpace) {
         Porffor.bytestring.appendChar(out, 10); // \n
         for (let i: i32 = 0; i < depth; i++) Porffor.bytestring.appendStr(out, space);
@@ -124,13 +123,12 @@ export const __Porffor_json_serialize = (value: any, depth: i32, space: bytestri
     const hasSpace: boolean = space !== undefined;
     depth += 1;
 
-    const obj: object = value;
-    for (const key in obj) {
+    for (const key in (value as object)) {
       // skip symbol keys
       if (Porffor.rawType(key) == Porffor.TYPES.symbol) continue;
 
       // skip non-serializable values (functions, etc)
-      const val: bytestring|undefined = __Porffor_json_serialize(obj[key], depth, space);
+      const val: bytestring|undefined = __Porffor_json_serialize((value as object)[key], depth, space);
       if (val == null) continue;
 
       if (hasSpace) {
@@ -169,6 +167,11 @@ export const __Porffor_json_serialize = (value: any, depth: i32, space: bytestri
     return out;
   }
 
+  if (t == 0x04) {
+    // bigint
+    throw new TypeError('Cannot serialize BigInts');
+  }
+
   return undefined;
 };
 

package/compiler/builtins/number.ts

@@ -9,10 +9,15 @@ export const Number = function (value: any): number|NumberObject {
   // todo: handle undefined (NaN) and not present (0) args differently
   if (Porffor.rawType(value) != Porffor.TYPES.undefined) {
     // a. Let prim be ? ToNumeric(value).
+    n = ecma262.ToNumeric(value);
+
     // b. If prim is a BigInt, let n be 𝔽(ℝ(prim)).
-    // todo: handle when bigints exist
+    if (Porffor.comptime.flag`hasType.bigint`) {
+      if (Porffor.rawType(n) == Porffor.TYPES.bigint)
+        n = Porffor.bigint.toNumber(n);
+    }
+
     // c. Otherwise, let n be prim.
-    n = ecma262.ToNumeric(value);
   }
 
   // 2. Else,
@@ -25,8 +30,7 @@ export const Number = function (value: any): number|NumberObject {
   // 4. Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%Number.prototype%", « [[NumberData]] »).
   // 5. Set O.[[NumberData]] to n.
   // 6. Return O.
-  const O: NumberObject = n;
-  return O;
+  return n as NumberObject;
 };
 
 // radix: number|any for rawType check