porffor 0.57.28 → 0.57.30

package/compiler/codegen.js

@@ -470,11 +470,18 @@ const lookup = (scope, name, failEarly = false) => {
         ...Opcodes.eqz,
         [ Opcodes.if, Blocktype.void ],
           ...generateObject(scope, {
-            properties: names.map((x, i) => ({
-              key: { type: 'Literal', value: i },
-              value: { type: 'Identifier', name: x },
-              kind: 'init'
-            }))
+            properties: [
+              {
+                key: { type: 'Literal', value: 'length' },
+                value: { type: 'Literal', value: len },
+                kind: 'init'
+              },
+              ...names.map((x, i) => ({
+                key: { type: 'Literal', value: i },
+                value: { type: 'Identifier', name: x },
+                kind: 'init'
+              }))
+            ]
           }, '#arguments', false),
           [ Opcodes.local_set, localTmp(scope, '#arguments') ],
         [ Opcodes.end ],
@@ -700,11 +707,14 @@ const generateReturn = (scope, decl) => {
     ];
   }
 
-  return [
-    ...generate(scope, arg),
-    ...(scope.returnType != null ? [] : getNodeType(scope, arg)),
-    [ Opcodes.return ]
-  ];
+  const out = generate(scope, arg);
+  if (scope.returns[0] === Valtype.f64 && valtypeBinary === Valtype.i32 && out[out.length - 1][0] !== Opcodes.f64_const && out[out.length - 1] !== Opcodes.i32_to_u)
+    out.push([ Opcodes.f64_convert_i32_s ]);
+
+  if (scope.returnType == null) out.push(...getNodeType(scope, arg));
+
+  out.push([ Opcodes.return ]);
+  return out;
 };
 
 const localTmp = (scope, name, type = valtypeBinary) => {
@@ -2536,7 +2546,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           [ Opcodes.local_get, calleeLocal ],
           Opcodes.i32_to_u,
           [ Opcodes.call_indirect, args.length + 2, 0 ],
-          ...setLastType(scope)
+          ...setLastType(scope),
+          ...(globalThis.precompile && valtypeBinary === Valtype.i32 ? [ Opcodes.i32_trunc_sat_f64_s ] : [])
         ],
 
         default: decl.optional ? withType(scope, [ number(UNDEFINED) ], TYPES.undefined)
@@ -2570,13 +2581,15 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (func && func.constr) {
-    out.push(...(decl._newTargetWasm ?? createNewTarget(scope, decl, idx - importedFuncs.length)));
-    out.push(...(decl._thisWasm ?? createThisArg(scope, decl)));
+    out.push(
+      ...forceDuoValtype(scope, decl._newTargetWasm ?? createNewTarget(scope, decl, idx - importedFuncs.length), func.params[0]),
+      ...forceDuoValtype(scope, decl._thisWasm ?? createThisArg(scope, decl), func.params[2])
+    );
     paramOffset += 4;
   }
 
   if (func && func.method) {
-    out.push(...(decl._thisWasm ?? createThisArg(scope, decl)));
+    out.push(...forceDuoValtype(scope, decl._thisWasm ?? createThisArg(scope, decl), func.params[0]));
     paramOffset += 2;
   }
 

package/compiler/opt.js

@@ -163,6 +163,19 @@ export default (funcs, globals, pages, tags, exceptions) => {
           continue;
         }
 
+        if (lastInst[0] === Opcodes.i32_trunc_sat_f64_s[0] && (inst[0] === Opcodes.f64_convert_i32_u || inst[0] === Opcodes.f64_convert_i32_s)) {
+          // remove unneeded f64 -> i32 -> f64
+          // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
+          // f64.convert_i32_s || f64.convert_i32_u
+          // -->
+          // <nothing>
+
+          wasm.splice(i - 1, 2); // remove this inst and last
+          i -= 2;
+          // if (Prefs.optLog) log('opt', `removed redundant f64 -> i32 -> f64 conversion ops`);
+          continue;
+        }
+
         if (lastInst[0] === Opcodes.const && inst[0] === Opcodes.i32_to[0] && (inst[1] === Opcodes.i32_to[1] || inst[1] === Opcodes.i32_to_u[1])) {
           // change const and immediate i32 convert to i32 const
           // f64.const 0

package/compiler/precompile.js

@@ -269,7 +269,7 @@ ${funcs.map(x => {
         return `[null,()=>{const r=()=>{valtype=Prefs.valtype??'f64';valtypeBinary=Valtype[valtype];Opcodes.const=valtypeBinary===Valtype.i32?Opcodes.i32_const:Opcodes.f64_const;Opcodes.eq=valtypeBinary===Valtype.i32?Opcodes.i32_eq:Opcodes.f64_eq;Opcodes.eqz=valtypeBinary===Valtype.i32?[[Opcodes.i32_eqz]]:[number(0),[Opcodes.f64_eq]];Opcodes.mul=valtypeBinary===Valtype.i32?Opcodes.i32_mul:Opcodes.f64_mul;Opcodes.add=valtypeBinary===Valtype.i32?Opcodes.i32_add:Opcodes.f64_add;Opcodes.sub=valtypeBinary===Valtype.i32?Opcodes.i32_sub:Opcodes.f64_sub;Opcodes.i32_to=valtypeBinary===Valtype.i32?[]:Opcodes.i32_trunc_sat_f64_s;Opcodes.i32_to_u=valtypeBinary===Valtype.i32?[]:Opcodes.i32_trunc_sat_f64_u;Opcodes.i32_from=valtypeBinary===Valtype.i32?[]:[Opcodes.f64_convert_i32_s];Opcodes.i32_from_u=valtypeBinary===Valtype.i32?[]:[Opcodes.f64_convert_i32_u];Opcodes.load=valtypeBinary===Valtype.i32?Opcodes.i32_load:Opcodes.f64_load;Opcodes.store=valtypeBinary===Valtype.i32?Opcodes.i32_store:Opcodes.f64_store};const a=Prefs;Prefs=${prefs};r();const b=generate(_,${comptimeFlagChecks[id](extra)}?${passAst}:${failAst});if(b.at(-1)[0]>=0x41&&b.at(-1)[0]<=0x44)b.pop();Prefs=a;r();return b;}]`;
       });
 
-    return `(_,{${str.includes('usedTypes.') ? 'usedTypes,' : ''}${str.includes('hasFunc(') ? 'hasFunc,' : ''}${str.includes('Valtype[') ? 'Valtype,' : ''}${str.includes('i32ify') ? 'i32ify,' : ''}${str.includes('Opcodes.') ? 'Opcodes,' : ''}${str.includes('...t(') ? 't,' : ''}${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('makeString(') ? 'makeString,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('funcRef(') ? 'funcRef,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}${str.includes('generateIdent(') ? 'generateIdent,' : ''}${str.includes('generate(') ? 'generate,' : ''}`.slice(0, -1)}})=>`.replace('_,{}', '') + str;
+    return `(_,{${str.includes('usedTypes.') ? 'usedTypes,' : ''}${str.includes('hasFunc(') ? 'hasFunc,' : ''}${str.includes('Valtype[') ? 'Valtype,' : ''}${str.includes('i32ify') ? 'i32ify,' : ''}${str.includes('Opcodes.') ? 'Opcodes,' : ''}${str.includes('...t(') ? 't,' : ''}${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('makeString(') ? 'makeString,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('funcRef(') ? 'funcRef,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}${str.includes('generateIdent(') ? 'generateIdent,' : ''}${str.includes('generate(') ? 'generate,' : ''}`.slice(0, -1)}})=>`.replace('_,{}', '') + `eval(${JSON.stringify(str)})`;
   };
 
   const locals = Object.entries(x.locals).sort((a,b) => a[1].idx - b[1].idx)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.57.28",
+  "version": "0.57.30",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/regex_notes.md

@@ -0,0 +1,74 @@
+**ES3 (1999)**
+*   Basic regex syntax (Perl-inspired)
+*   `RegExp` object
+*   `test()`, `exec()` methods for `RegExp`
+*   `match()`, `replace()`, `search()`, `split()` methods for `String`
+*   **Flags:**
+    *   `g` (global)
+    *   `i` (ignore case)
+    *   `m` (multiline) - `^` and `$` match start/end of lines, not just start/end of string.
+*   **Special Characters/Constructs:**
+    *   `.` (wildcard - matches any character except newline)
+    *   `\d`, `\D` (digit, non-digit)
+    *   `\w`, `\W` (word character, non-word character)
+    *   `\s`, `\S` (whitespace, non-whitespace)
+    *   `\t`, `\r`, `\n`, `\v`, `\f` (tab, carriage return, line feed, vertical tab, form feed)
+    *   `[...]`, `[^...]` (character classes)
+    *   `^`, `$` (start/end of string/line - see `m` flag)
+    *   `\b`, `\B` (word boundary, non-word boundary)
+    *   `(...)` (capturing group)
+    *   `(?:...)` (non-capturing group)
+    *   `\1`, `\2`, ... (backreferences to capturing groups)
+    *   `|` (alternation/OR)
+    *   `*`, `+`, `?` (quantifiers: zero or more, one or more, zero or one)
+    *   `{n}`, `{n,}`, `{n,m}` (quantifiers: exactly n, at least n, between n and m)
+    *   `*?`, `+?`, `??`, `{n}?`, `{n,}?`, `{n,m}?` (lazy quantifiers)
+    *   `(?=...)` (positive lookahead)
+    *   `(?!...)` (negative lookahead)
+
+**ES5 (2009)**
+*   Regex literals `(/abc/)` now create a new object each time they are evaluated.
+*   Unescaped forward slashes allowed within character classes (e.g., `/[/]/`).
+
+**ES6/ES2015**
+*   **New Flags:**
+    *   `u` (unicode): Enables stricter parsing, improved handling of Unicode surrogate pairs, and allows `\u{...}` for Unicode code points.
+    *   `y` (sticky): The match must start at the `lastIndex` property of the `RegExp`.
+*   `RegExp.prototype.flags` getter: Returns a string containing the flags of the regex.
+*   Support for subclassing `RegExp`.
+*   Ability to copy a regex while changing its flags: `new RegExp(/ab+c/, 'i')`.
+
+**ES2018 (ES9)**
+*   **New Flag:**
+    *   `s` (dotAll/singleline): Causes `.` to match newline characters as well.
+*   **Lookbehind Assertions:**
+    *   `(?<=...)` (positive lookbehind)
+    *   `(?<!...)` (negative lookbehind)
+*   **Named Capture Groups:**
+    *   `(?<name>...)` (defines a named capture group)
+    *   `\k<name>` (backreference to a named capture group)
+    *   Named groups are accessible via the `groups` property of the match object.
+*   **Unicode Property Escapes:** (Requires `u` or `v` flag)
+    *   `\p{PropertyName}` (e.g., `\p{Script=Greek}`, `\p{Number}`, `\p{Alphabetic}`)
+    *   `\P{PropertyName}` (negated version)
+
+**ES2020 (ES11)**
+*   `String.prototype.matchAll()`: Returns an iterator of all results matching a global regular expression against a string. (Requires the `g` flag).
+
+**ES2021 (ES12)**
+* `String.prototype.replaceAll()`: Replaces all occurrences of a substring (can be a regex). If a regex is used, it must have the `g` flag.
+
+**ES2022 (ES13)**
+*   **New Flag:**
+    *   `d` (hasIndices): Provides start and end indices for matched substrings (and capturing groups) via the `indices` property on the match object.
+
+**ES2024 (ES15)**
+*   **New Flag:**
+    *   `v` (unicodeSets): An upgrade to the `u` flag (cannot be used with `u`).
+        *   Adds set notation for strings of characters to `\p{...}` and `\q{...}` (matching literal strings) within character classes.
+        *   Nested character classes.
+        *   Set operations within character classes:
+            *   Subtraction: `[A--B]` (characters in A but not in B)
+            *   Intersection: `[A&&B]` (characters in both A and B)
+        *   Improved case-insensitive matching for Unicode properties within negated sets `[^...]`.
+        *   `\p{RGI_Emoji}` for matching complete emojis.

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.57.28';
+globalThis.version = '0.57.30';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/foo.js

@@ -1,8 +0,0 @@
-const a = {
-  b: {
-    c: () => {}
-  },
-  c: () => {}
-};
-
-a.c();