porffor 0.57.26 → 0.57.28

package/compiler/codegen.js

@@ -4,7 +4,6 @@ import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { PrototypeFuncs } from './prototype.js';
 import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
-import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
 import { allocPage, allocStr } from './allocator.js';
@@ -1256,28 +1255,16 @@ const generateBinaryExp = (scope, decl) => {
 const asmFuncToAsm = (scope, func, extra) => func(scope, {
   Valtype, Opcodes, TYPES, TYPE_NAMES, usedTypes, typeSwitch, makeString, internalThrow,
   getNodeType, generate, generateIdent,
-  builtin: (n, offset = false) => {
-    let idx = importedFuncs[n] ?? funcIndex[n];
-    if (idx == null && Object.hasOwn(builtinFuncs, n)) {
-      includeBuiltin(scope, n);
-      idx = funcIndex[n];
-    }
-
-    scope.includes ??= new Set();
-    scope.includes.add(n);
-
-    if (idx == null) throw new Error(`builtin('${n}') failed: could not find func (from ${scope.name})`);
+  builtin: (name, offset = false) => {
+    let idx = importedFuncs[name] ?? includeBuiltin(scope, name)?.index;
+    if (idx == null) throw new Error(`builtin('${name}') failed: could not find func (from ${scope.name})`);
     if (offset) idx -= importedFuncs.length;
 
     return idx;
   },
   hasFunc: x => funcIndex[x] != null,
   funcRef: name => {
-    if (funcIndex[name] == null && Object.hasOwn(builtinFuncs, name)) {
-      includeBuiltin(scope, name);
-    }
-
-    const func = funcByName(name);
+    const func = includeBuiltin(scope, name);
     return funcRef(func);
   },
   glbl: (opcode, name, type) => {
@@ -1341,7 +1328,7 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
     wasm = [];
   }
 
-  const existing = funcByName(name);
+  const existing = builtinFuncByName(name);
   if (existing) return existing;
 
   const allLocals = params.concat(localTypes);
@@ -1580,9 +1567,7 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
-
       if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES.bytestring;
-
       return TYPES[typeof node.value];
     }
 
@@ -1786,9 +1771,25 @@ const getNodeType = (scope, node) => {
 const generateLiteral = (scope, decl, global, name) => {
   if (decl.value === null) return [ number(NULL) ];
 
-  // hack: just return 1 for regex literals
   if (decl.regex) {
-    return [ number(1) ];
+    // todo/opt: separate aot compiling regex engine for compile-time known regex (literals, known RegExp args)
+    return generate(scope, {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'RegExp'
+      },
+      arguments: [
+        {
+          type: 'Literal',
+          value: decl.regex.pattern
+        },
+        {
+          type: 'Literal',
+          value: decl.regex.flags
+        }
+      ]
+    });
   }
 
   switch (typeof decl.value) {
@@ -2152,35 +2153,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const prop = (decl.callee.expression ?? decl.callee).property;
     const object = (decl.callee.expression ?? decl.callee).object;
 
-    // megahack for /regex/.func()
-    if (object?.regex && ['test'].includes(prop.name)) {
-      const regex = object.regex.pattern;
-      const rhemynName = `regex_${prop.name}_${sanitize(regex)}`;
-
-      if (!funcIndex[rhemynName]) {
-        const func = Rhemyn[prop.name](regex, currentFuncIndex++, rhemynName);
-        func.internal = true;
-
-        funcIndex[func.name] = func.index;
-        funcs.push(func);
-      }
-
-      const arg = decl.arguments[0] ?? DEFAULT_VALUE();
-      const idx = funcIndex[rhemynName];
-      return [
-        // make string arg
-        ...generate(scope, arg),
-        Opcodes.i32_to_u,
-        ...getNodeType(scope, arg),
-
-        // call regex func
-        [ Opcodes.call, idx ],
-        Opcodes.i32_from_u,
-
-        ...setLastType(scope, Rhemyn.types[prop.name])
-      ];
-    }
-
     protoName = prop?.name;
     target = object;
   }
@@ -2213,42 +2185,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       });
     }
 
-    if (['search'].includes(protoName)) {
-      const regex = decl.arguments[0]?.regex?.pattern;
-      if (!regex) return [
-        // no/bad regex arg, return -1/0 for now
-        ...generate(scope, target),
-        [ Opcodes.drop ],
-
-        number(Rhemyn.types[protoName] === TYPES.number ? -1 : 0),
-        ...setLastType(scope, Rhemyn.types[protoName])
-      ];
-
-      const rhemynName = `regex_${protoName}_${sanitize(regex)}`;
-
-      if (!funcIndex[rhemynName]) {
-        const func = Rhemyn[protoName](regex, currentFuncIndex++, rhemynName);
-        func.internal = true;
-
-        funcIndex[func.name] = func.index;
-        funcs.push(func);
-      }
-
-      const idx = funcIndex[rhemynName];
-      return [
-        // make string arg
-        ...generate(scope, target),
-        Opcodes.i32_to_u,
-        ...getNodeType(scope, target),
-
-        // call regex func
-        [ Opcodes.call, idx ],
-        Opcodes.i32_from,
-
-        ...setLastType(scope, Rhemyn.types[protoName])
-      ];
-    }
-
     const protoBC = {};
     const builtinProtoCands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + protoName));
 
@@ -2550,20 +2486,24 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           [ Opcodes.local_get, thisLocal ],
           [ Opcodes.local_get, thisLocalType ]
         ];
-        getCallee = [
-          ...generate(scope, object),
-          [ Opcodes.local_set, thisLocal ],
-          ...getNodeType(scope, object),
-          [ Opcodes.local_set, thisLocalType ],
-
-          ...generate(scope, {
-            type: 'MemberExpression',
-            object: { type: 'Identifier', name: tmpName + 'caller' },
-            property,
-            computed,
-            optional
-          })
-        ];
+        getCallee = generate(scope, {
+          type: 'MemberExpression',
+          object: {
+            type: 'Wasm',
+            wasm: () => [
+              ...generate(scope, object),
+              [ Opcodes.local_tee, thisLocal ],
+              ...getNodeType(scope, object),
+              [ Opcodes.local_set, thisLocalType ]
+            ],
+            _type: [
+              [ Opcodes.local_get, thisLocalType ]
+            ]
+          },
+          property,
+          computed,
+          optional
+        });
       }
     }
 
@@ -3583,6 +3523,9 @@ const memberTmpNames = scope => {
   };
 };
 
+// todo: generate this array procedurally
+const builtinPrototypeGets = ['size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'name', 'message', 'constructor', 'source', 'flags', 'global', 'ignoreCase', 'multiline', 'dotAll', 'unicode', 'sticky', 'hasIndices', 'unicodeSets'];
+
 const ctHash = prop => {
   if (!Prefs.ctHash || !prop ||
     prop.computed || prop.optional ||
@@ -3618,7 +3561,9 @@ const coctcOffset = prop => {
   ) return 0;
 
   prop = prop.property.name;
-  if (!prop || ['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'name', 'message', 'constructor', 'length', '__proto__'].includes(prop)) return 0;
+  if (!prop || builtinPrototypeGets.includes(prop) ||
+    prop === 'prototype' || prop === 'length' || prop === '__proto__'
+  ) return 0;
 
   let offset = coctc.get(prop);
   if (offset == null) {
@@ -5853,8 +5798,7 @@ const generateMember = (scope, decl, _global, _name) => {
   const type = getNodeType(scope, object);
   const known = knownType(scope, type);
 
-  // todo: generate this array procedurally during builtinFuncs creation
-  if (['size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'name', 'message', 'constructor'].includes(decl.property.name)) {
+  if (builtinPrototypeGets.includes(decl.property.name)) {
     // todo: support optional
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
@@ -6587,6 +6531,13 @@ const funcByIndex = idx => {
 };
 const funcByName = name => funcByIndex(funcIndex[name]);
 
+const builtinFuncByName = name => {
+  const normal = funcByName(name);
+  if (!normal || normal.internal) return normal;
+
+  return funcs.find(x => x.name === name && x.internal);
+};
+
 const generateFunc = (scope, decl, forceNoExpr = false) => {
   doNotMarkFuncRef = false;
 

package/compiler/wrap.js

@@ -348,6 +348,14 @@ ${flags & 0b0001 ? `    get func idx: ${get}
       return negative ? -result : result;
     }
 
+    case TYPES.regexp: {
+      const [ pattern, flags ] = read(Uint32Array, memory, value, 2);
+      return new RegExp(
+        porfToJSValue({ memory, funcs, pages }, pattern, TYPES.bytestring),
+        porfToJSValue({ memory, funcs, pages }, flags, TYPES.bytestring)
+      );
+    }
+
     default: return value;
   }
 };

package/foo.js

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

package/package.json

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

package/runtime/index.js

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

package/rhemyn/README.md

@@ -1,40 +0,0 @@
-# Rhemyn
-A basic experimental WIP regex engine/AOT Wasm compiler in JS. Regex engine for Porffor! Uses own regex parser, no dependencies (excluding porffor internals). <br>
-Age: ~1 day (of work)
-
-Made for use with Porffor but could possibly be adapted, implementation/library notes:
-- Exposes functions for each regex "operation" (eg test, match)
-- Given a regex pattern string (eg `a+`), it returns a "function" object
-- Wasm function returned expects an i32 pointer to a UTF-16 string (can add UTF-8 option later if someone else actually wants to use this)
-
-## syntax
-🟢 supported 🟡 partial 🟠 parsed only 🔴 unsupported
-
-- 🟢 literal characters (eg `a`)
-- 🟢 escaping (eg `\.\n\cJ\x0a\u000a`)
-  - 🟢 character itself (eg `\.`)
-  - 🟢 escape sequences (eg `\n`)
-  - 🟢 control character (eg `\cJ`)
-  - 🟢 unicode code points (eg `\x00`, `\u0000`)
-- 🟢 sets (eg `[ab]`)
-  - 🟢 ranges (eg `[a-z]`)
-  - 🟢 negated sets (eg `[^ab]`)
-- 🟢 metacharacters
-  - 🟢 dot (eg `a.b`)
-  - 🟢 digit, not digit (eg `\d\D`)
-  - 🟢 word, not word (eg `\w\W`)
-  - 🟢 whitespace, not whitespace (eg `\s\S`)
-- 🟡 quantifiers
-  - 🟡 star (eg `a*`)
-  - 🟡 plus (eg `a+`)
-  - 🟡 optional (eg `a?`)
-  - 🟠 lazy modifier (eg `a*?`)
-  - 🔴 n repetitions (eg `a{4}`)
-  - 🔴 n-m repetitions (eg `a{2,4}`)
-- 🟠 groups
-  - 🟠 capturing groups (`(a)`)
-  - 🔴 non-capturing groups (`(?:a)`)
-- 🔴 assertions
-  - 🔴 beginning (eg `^a`)
-  - 🔴 end (eg `a$`)
-  - 🔴 word boundary assertion (eg `\b\B`)

package/rhemyn/compile.js

@@ -1,331 +0,0 @@
-import { Blocktype, Opcodes, Valtype, ValtypeSize } from '../compiler/wasmSpec.js';
-import { number } from '../compiler/encoding.js';
-import parse from './parse.js';
-import { TYPES } from '../compiler/types.js';
-import '../compiler/prefs.js';
-
-// local indexes
-const BasePointer = 0; // base string pointer
-const Counter = 2; // what char we are running on
-const Pointer = 3; // next char pointer
-const Length = 4;
-const Tmp = 5;
-const QuantifierTmp = 6; // the temporary variable used for quanitifers
-
-const doesSucceedZero = node => {
-  for (const n of node.body) {
-    if (n.type === 'Group') {
-      if (!doesSucceedZero(n)) return false;
-    }
-
-    if (!n.quantifier || n.quantifier[0] > 0) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-const generate = (node, negated = false, get = true, stringSize = 2, func = 'test') => {
-  let out = [];
-  switch (node.type) {
-    case 'Expression':
-      let succeedsZero = doesSucceedZero(node);
-
-      out = [
-        // set length local
-        [ Opcodes.local_get, BasePointer ],
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-        [ Opcodes.local_tee, Length ],
-
-        number(0, Valtype.i32),
-        [ Opcodes.i32_eq ],
-        [ Opcodes.if, Blocktype.void ],
-          number(succeedsZero ? 1 : 0, Valtype.i32),
-          [ Opcodes.return ],
-        [ Opcodes.end ],
-
-        // pointer = base + sizeof i32
-        [ Opcodes.local_get, BasePointer ],
-        number(ValtypeSize.i32, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_set, Pointer ],
-
-        [ Opcodes.loop, Blocktype.void ],
-          [ Opcodes.block, Blocktype.void ],
-            // generate checks
-            ...node.body.flatMap(x => generate(x, negated, true, stringSize, func)),
-
-            // reached end without branching out, successful match
-            ...({
-              test: [
-                number(1, Valtype.i32)
-              ],
-              search: [
-                [ Opcodes.local_get, Counter ]
-              ]
-            })[func],
-            [ Opcodes.return ],
-          [ Opcodes.end ],
-
-          // counter++, if length > counter, loop
-          [ Opcodes.local_get, Length ],
-
-          [ Opcodes.local_get, Counter ],
-          number(1, Valtype.i32),
-          [ Opcodes.i32_add ],
-          [ Opcodes.local_tee, Counter ],
-
-          [ Opcodes.i32_gt_s ],
-
-          [ Opcodes.br_if, 0 ],
-        [ Opcodes.end ],
-
-        // no match
-        number(({
-          test: 0,
-          search: -1
-        })[func], Valtype.i32)
-      ];
-
-      if (Prefs.regexLog) {
-        const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
-        console.log(`\n${underline('ast')}`);
-        console.log(node);
-        console.log(`\n${underline('wasm bytecode')}\n` + disassemble(out) + '\n');
-      }
-
-      break;
-
-    case 'Character':
-      out = generateChar(node, node.negated ^ negated, get, stringSize);
-      break;
-
-    case 'Set':
-      out = generateSet(node, node.negated, get, stringSize);
-      break;
-
-    case 'Group':
-      out = generateGroup(node, negated, get, stringSize);
-      break;
-
-    case 'Range':
-      out = generateRange(node, negated, get, stringSize);
-      break;
-  }
-
-  return out;
-};
-
-const getNextChar = (stringSize, peek = false) => [
-  // get char from pointer
-  [ Opcodes.local_get, Pointer ],
-  [ stringSize == 2 ? Opcodes.i32_load16_u : Opcodes.i32_load8_u, 0, 0 ],
-
-  ...(peek ? [] : [
-    // pointer += string size
-    [ Opcodes.local_get, Pointer ],
-    number(stringSize, Valtype.i32),
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_set, Pointer ]
-  ])
-];
-
-const checkFailure = () => [
-  // surely we do not need to do this for every single mismatch, right?
-  /* [ Opcodes.if, Blocktype.void ],
-  number(0, Valtype.i32),
-  [ Opcodes.return ],
-  [ Opcodes.end ], */
-
-  [ Opcodes.br_if, 0 ]
-];
-
-const wrapQuantifier = (node, method, get, stringSize) => {
-  const [ min, max ] = node.quantifier;
-  return [
-    // initalize our temp value (number of matched characters)
-    number(0, Valtype.i32),
-    [Opcodes.local_set, QuantifierTmp],
-
-    // if len - counter == 0, if min == 0, succeed, else fail
-    [ Opcodes.local_get, Length ],
-    [ Opcodes.local_get, Counter ],
-    [ Opcodes.i32_sub ],
-    number(0, Valtype.i32),
-    [ Opcodes.i32_eq ],
-    ...(min == 0 ? [
-      [ Opcodes.if, Blocktype.void ],
-    ] : [
-      [ Opcodes.br_if, 0 ],
-    ]),
-
-    // start loop
-    [Opcodes.loop, Blocktype.void],
-      [ Opcodes.block, Blocktype.void ],
-        // if counter + tmp == length, break
-        [ Opcodes.local_get, Counter ],
-        [ Opcodes.local_get, QuantifierTmp ],
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_get, Length ],
-        [ Opcodes.i32_eq ],
-        [ Opcodes.br_if, 0 ],
-
-        // if doesn't match, break
-        ...method,
-        [Opcodes.br_if, 0 ],
-        ...(get ? [
-          // pointer += stringSize
-          [ Opcodes.local_get, Pointer ],
-          number(stringSize, Valtype.i32),
-          [ Opcodes.i32_add ],
-          [ Opcodes.local_set, Pointer ]
-        ] : []),
-
-        // if maximum was reached, break
-        ...(max ? [
-          [ Opcodes.local_get, QuantifierTmp ],
-          number(max, Valtype.i32),
-          [ Opcodes.i32_eq ],
-          [ Opcodes.br_if, 0 ]
-        ] : []),
-
-        [ Opcodes.local_get, QuantifierTmp ],
-        number(1, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_set, QuantifierTmp ],
-        [ Opcodes.br, 1 ],
-      [ Opcodes.end ],
-    [ Opcodes.end ],
-
-    // if less than minimum, fail
-    [Opcodes.local_get, QuantifierTmp],
-    number(min, Valtype.i32),
-    [Opcodes.i32_lt_s],
-    ...(get ? checkFailure(): []),
-
-    ...(min == 0 ? [ [ Opcodes.end ] ] : []),
-  ];
-}
-
-const generateChar = (node, negated, get, stringSize) => {
-  const hasQuantifier = !!node.quantifier;
-  const out = [
-    ...(get ? getNextChar(stringSize, hasQuantifier) : []),
-    number(node.char.charCodeAt(0), Valtype.i32),
-    negated ? [ Opcodes.i32_eq ] : [ Opcodes.i32_ne ],
-  ];
-
-  if (node.quantifier) {
-    return wrapQuantifier(node, out, get, stringSize);
-  }
-
-  return [
-    ...out,
-    ...(get ? checkFailure(): []),
-  ];
-};
-
-const generateSet = (node, negated, get, stringSize) => {
-  // for a single char we do not need a tmp, it is like just
-  const singleChar = node.body.length === 1 && node.body[0].type === 'Character';
-  if (singleChar) return generateChar(node.body[0], negated, get, stringSize)
-
-  const hasQuantifier = !!node.quantifier;
-
-  const out = [
-    ...(get ? getNextChar(stringSize, hasQuantifier) : []),
-    [ Opcodes.local_set, Tmp ],
-  ];
-
-  for (const x of node.body) {
-    out.push(
-      [ Opcodes.local_get, Tmp ],
-      ...generate(x, negated, false, stringSize)
-    );
-  }
-
-  if (node.body.length > 0) {
-    for (let i = 0; i < node.body.length - 1; i++) {
-      out.push(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ])
-    }
-  };
-
-  if (hasQuantifier) {
-    return wrapQuantifier(node, out, get, stringSize);
-  }
-
-  return [
-    ...out,
-    ...checkFailure(),
-  ];
-};
-
-const generateRange = (node, negated, get, stringSize) => {
-  return [
-    ...(get ? getNextChar(stringSize) : []),
-    ...(get ? [ [ Opcodes.local_tee, Tmp ] ] : []),
-
-    number(node.from.charCodeAt(0), Valtype.i32),
-    // negated ? [ Opcodes.i32_lt_s ] : [ Opcodes.i32_ge_s ],
-    negated ? [ Opcodes.i32_ge_s ] : [ Opcodes.i32_lt_s ],
-
-    [ Opcodes.local_get, Tmp ],
-    number(node.to.charCodeAt(0), Valtype.i32),
-    // negated ? [ Opcodes.i32_gt_s ] : [ Opcodes.i32_le_s ],
-    negated ? [ Opcodes.i32_le_s ] : [ Opcodes.i32_gt_s ],
-
-    negated ? [ Opcodes.i32_and ] : [ Opcodes.i32_or ],
-    ...(get ? checkFailure(): [])
-  ];
-};
-
-const generateGroup = (node, negated, get) => {
-  // todo
-  return [];
-};
-
-const wrapFunc = (regex, func, name, index) => {
-  const parsed = parse(regex);
-
-  return outputFunc([
-    [ Opcodes.local_get, 1 ],
-    number(TYPES.string, Valtype.i32),
-    [ Opcodes.i32_eq ],
-    [ Opcodes.if, Valtype.i32 ],
-    // string
-    ...generate(parsed, false, true, 2, func),
-    [ Opcodes.else ],
-    // bytestring
-    ...generate(parsed, false, true, 1, func),
-    [ Opcodes.end ]
-  ], name, index, types[func]);
-};
-
-export const test = (regex, index = 0, name = 'regex_test_' + regex) => wrapFunc(regex, 'test', name, index);
-export const search = (regex, index = 0, name = 'regex_search_' + regex) => wrapFunc(regex, 'search', name, index);
-
-export const types = {
-  test: TYPES.boolean,
-  search: TYPES.number
-};
-
-const outputFunc = (wasm, name, index, returnType) => ({
-  name,
-  index,
-  wasm,
-  returnType,
-
-  export: true,
-  params: [ Valtype.i32, Valtype.i32 ],
-  returns: [ Valtype.i32 ],
-  locals: {
-    basePointer: { idx: 0, type: Valtype.i32 },
-    inputType: { idx: 1, type: Valtype.i32 },
-    counter: { idx: 2, type: Valtype.i32 },
-    pointer: { idx: 3, type: Valtype.i32 },
-    length: { idx: 4, type: Valtype.i32 },
-    tmp: { idx: 5, type: Valtype.i32 },
-    quantifierTmp: { idx: 6, type: Valtype.i32 },
-  }
-});