porffor 0.30.14 → 0.33.0

package/compiler/codegen.js

@@ -37,7 +37,8 @@ const todo = (scope, msg, expectsValue = undefined) => {
 };
 
 const isFuncType = type =>
-  type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
+  type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression' ||
+  type === 'ClassDeclaration' || type === 'ClassExpression';
 const hasFuncWithName = name =>
   Object.hasOwn(funcIndex, name) || Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(internalConstrs, name);
 
@@ -70,7 +71,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
-    case 'FunctionExpression':
+    case 'FunctionExpression': {
       const func = generateFunc(scope, decl);
 
       if (decl.type.endsWith('Expression')) {
@@ -78,6 +79,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       }
 
       return cacheAst(decl, []);
+    }
 
     case 'BlockStatement':
       return cacheAst(decl, generateCode(scope, decl));
@@ -175,6 +177,10 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'MemberExpression':
       return cacheAst(decl, generateMember(scope, decl, global, name));
 
+    case 'ClassExpression':
+    case 'ClassDeclaration':
+      return cacheAst(decl, generateClass(scope, decl));
+
     case 'ExportNamedDeclaration':
       if (!decl.declaration) return todo(scope, 'unsupported export declaration');
 
@@ -1218,7 +1224,7 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
       type: 'CallExpression',
       callee: {
         type: 'Identifier',
-        name: '__Object_hasOwn'
+        name: '__Porffor_object_in'
       },
       arguments: [
         decl.right,
@@ -1327,12 +1333,8 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
     locals[nameParam(i)] = { idx: i, type: allLocals[i] };
   }
 
-  for (const x of _data) {
-    let offset = x[0];
-    if (offset != null) offset += pages.size * pageSize;
-
-    const bytes = x[1];
-    data.push({ offset, bytes });
+  for (const x in _data) {
+    data.push({ page: x, bytes: _data[x] });
   }
 
   const func = {
@@ -1515,6 +1517,7 @@ const setLastType = (scope, type = []) => [
 
 const getNodeType = (scope, node) => {
   const ret = (() => {
+    if (node._type) return node._type;
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
 
@@ -1675,10 +1678,7 @@ const getNodeType = (scope, node) => {
 
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
-        if (name === 'length') {
-          if (typeHasFlag(objectKnownType, TYPE_FLAGS.length)) return TYPES.number;
-            else return TYPES.undefined;
-        }
+        if (name === 'length' && typeHasFlag(objectKnownType, TYPE_FLAGS.length)) return TYPES.number;
 
         if (node.computed) {
           if (objectKnownType === TYPES.string) return TYPES.string;
@@ -1702,12 +1702,12 @@ const getNodeType = (scope, node) => {
       }
     }
 
-    if (node.type == 'ThisExpression') {
+    if (node.type === 'ThisExpression') {
       if (!scope.constr) return getType(scope, 'globalThis');
       return [ [ Opcodes.local_get, '#this#type' ] ];
     }
 
-    if (node.type == 'MetaProperty') {
+    if (node.type === 'MetaProperty') {
       switch (`${node.meta.name}.${node.property.name}`) {
         case 'new.target': {
           return [ [ Opcodes.local_get, '#newtarget#type' ] ];
@@ -3221,12 +3221,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
                 },
                 arguments: [
                   { type: 'Identifier', name: tmpName },
-                  { type: 'Literal', value: i },
-                  {
-                    type: 'MemberExpression',
-                    object: { type: 'Identifier', name: tmpName, },
-                    property: { type: 'Identifier', name: 'length', }
-                  }
+                  { type: 'Literal', value: i }
                 ],
                 _protoInternalCall: true
               }, undefined, global)
@@ -3419,15 +3414,16 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const op = decl.operator.slice(0, -1) || '=';
 
   // hack: .length setter
-  if (type === 'MemberExpression' && decl.left.property.name === 'length') {
+  if (type === 'MemberExpression' && decl.left.property.name === 'length' && !decl._internalAssign) {
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
-    const pointerTmp = op === '=' ? null : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
+    const pointerTmp = localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
-    return [
+    const out = [
       ...generate(scope, decl.left.object),
-      Opcodes.i32_to_u,
-      ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+      Opcodes.i32_to_u
+    ];
 
+    const lengthTypeWasm = [
       ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
         [ Opcodes.local_get, pointerTmp ],
         [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
@@ -3440,6 +3436,33 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
       [ Opcodes.local_get, newValueTmp ]
     ];
+
+    const type = getNodeType(scope, decl.left.object);
+    const known = knownType(scope, type);
+    if (known != null && typeHasFlag(known, TYPE_FLAGS.length)) return [
+      ...out,
+      ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+      ...lengthTypeWasm
+    ];
+
+    return [
+      ...out,
+      [ Opcodes.local_set, pointerTmp ],
+
+      ...type,
+      ...number(TYPE_FLAGS.length, Valtype.i32),
+      [ Opcodes.i32_and ],
+      [ Opcodes.if, valtypeBinary ],
+        [ Opcodes.local_get, pointerTmp ],
+        ...lengthTypeWasm,
+      [ Opcodes.else ],
+        ...generate(scope, {
+          ...decl,
+          _internalAssign: true
+        }),
+      [ Opcodes.end ]
+    ];
   }
 
   // arr[i]
@@ -4951,7 +4974,7 @@ const compileBytes = (val, itemType) => {
   }
 };
 
-const makeData = (scope, elements, offset = null, itemType, initEmpty) => {
+const makeData = (scope, elements, page = null, itemType, initEmpty) => {
   const length = elements.length;
 
   // if length is 0 memory/data will just be 0000... anyway
@@ -4965,8 +4988,7 @@ const makeData = (scope, elements, offset = null, itemType, initEmpty) => {
     bytes.push(...compileBytes(elements[i], itemType));
   }
 
-  const obj = { bytes };
-  if (offset != null) obj.offset = offset;
+  const obj = { bytes, page };
 
   const idx = data.push(obj) - 1;
 
@@ -5068,7 +5090,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
       (!globalThis.precompile || !global)
     ) {
       if (Prefs.activeData && firstAssign) {
-        makeData(scope, elements, rawPtr, itemType, initEmpty);
+        makeData(scope, elements, allocator.lastName, itemType, initEmpty);
 
         // local value as pointer
         return [ number(rawPtr, intOut ? Valtype.i32 : valtypeBinary), pointer ];
@@ -5363,6 +5385,7 @@ const countLength = (func, name = undefined) => {
 };
 
 const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) => {
+  let final = [], finalEnd, extraBC = {};
   const name = decl.object.name;
 
   // hack: .name
@@ -5375,6 +5398,12 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     return withType(scope, makeString(scope, nameProp, _global, _name, true), TYPES.bytestring);
   }
 
+  const object = decl.object;
+  const property = getMemberProperty(decl);
+
+  // generate now so type is gotten correctly later (it gets cached)
+  generate(scope, object);
+
   // hack: .length
   if (decl.property.name === 'length') {
     // todo: support optional
@@ -5389,7 +5418,7 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     }
 
     const out = [
-      ...generate(scope, decl.object),
+      ...generate(scope, object),
       Opcodes.i32_to_u,
     ];
 
@@ -5403,25 +5432,21 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
       ];
     }
 
-    const type = getNodeType(scope, decl.object);
+    const type = getNodeType(scope, object);
     const known = knownType(scope, type);
-    if (known != null && known != TYPES.function) {
-      if (typeHasFlag(known, TYPE_FLAGS.length)) return [
-        ...out,
-
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-        Opcodes.i32_from_u
-      ];
+    if (known != null && typeHasFlag(known, TYPE_FLAGS.length)) return [
+      ...out,
 
-      return number(0);
-    }
+      [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+      Opcodes.i32_from_u
+    ];
 
     const tmp = localTmp(scope, '#length_tmp', Valtype.i32);
-    return [
+    final = [
       ...out,
       [ Opcodes.local_set, tmp ],
 
-      ...getNodeType(scope, decl.object),
+      ...getNodeType(scope, object),
       ...number(TYPE_FLAGS.length, Valtype.i32),
       [ Opcodes.i32_and ],
       [ Opcodes.if, valtypeBinary ],
@@ -5431,22 +5456,14 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
 
         ...setLastType(scope, TYPES.number),
       [ Opcodes.else ],
-        ...getNodeType(scope, decl.object),
-        ...number(TYPES.function, Valtype.i32),
-        [ Opcodes.i32_eq ],
-        [ Opcodes.if, Blocktype.void ],
-          [ Opcodes.local_get, tmp ],
-          [ Opcodes.call, includeBuiltin(scope, '__Porffor_funcLut_length').index ],
-          Opcodes.i32_from_u,
-
-          ...setLastType(scope, TYPES.number),
-          [ Opcodes.br, 1 ],
-        [ Opcodes.end ],
-
-        ...number(0),
-        ...setLastType(scope, TYPES.undefined),
       [ Opcodes.end ]
     ];
+
+    if (known != null) {
+      final = [];
+    } else {
+      finalEnd = final.pop();
+    }
   }
 
   // todo: generate this array procedurally during builtinFuncs creation
@@ -5455,33 +5472,67 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
 
+    localTmp(scope, '#member_obj');
+    localTmp(scope, '#member_obj#type', Valtype.i32);
+
+    const known = knownType(scope, getNodeType(scope, object));
     if (cands.length > 0) {
       for (const x of cands) {
         const type = TYPES[x.split('_prototype_')[0].slice(2).toLowerCase()];
         if (type == null) continue;
 
+        if (type === known) return generateCall(scope, {
+          callee: {
+            type: 'Identifier',
+            name: x
+          },
+          arguments: [ object ],
+          _protoInternalCall: true
+        });
+
         bc[type] = generateCall(scope, {
           callee: {
             type: 'Identifier',
             name: x
           },
-          arguments: [ decl.object ],
+          arguments: [
+            { type: 'Identifier', name: '#member_obj' }
+          ],
           _protoInternalCall: true
         });
       }
     }
 
-    return typeSwitch(scope, getNodeType(scope, decl.object), {
-      ...bc,
-      default: withType(scope, number(0), TYPES.undefined)
-    }, valtypeBinary);
+    if (known == null) extraBC = bc;
   }
 
-  const object = decl.object;
-  const property = getMemberProperty(decl);
+  if (decl.property.name === '__proto__') {
+    // todo: support optional
+    const bc = {};
+    const prototypes = Object.keys(builtinVars).filter(x => x.endsWith('_prototype'));
 
-  // generate now (it gets cached)
-  generate(scope, object);
+    const known = knownType(scope, getNodeType(scope, decl.object));
+    for (const x of prototypes) {
+      const type = TYPES[x.split('_prototype')[0].slice(2).toLowerCase()];
+      if (type == null) continue;
+
+      // do not __proto__ primitive hack for objects
+      if (type === TYPES.object) continue;
+
+      const ident = {
+        type: 'Identifier',
+        name: x
+      };
+
+      bc[type] = [
+        ...generateIdent(scope, ident),
+        ...setLastType(scope, getNodeType(scope, ident))
+      ];
+      if (type === known) return bc[type];
+    }
+
+    if (known == null) extraBC = bc;
+  }
 
   // todo/perf: use i32 object (and prop?) locals
   const objectWasm = [ [ Opcodes.local_get, localTmp(scope, '#member_obj') ] ];
@@ -5668,7 +5719,9 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     default: [
       ...number(0),
       ...setLastType(scope, TYPES.undefined)
-    ]
+    ],
+
+    ...extraBC
   });
 
   if (decl.optional) {
@@ -5676,6 +5729,10 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
       [ Opcodes.block, valtypeBinary ],
       ...(_objectWasm ? _objectWasm : generate(scope, object)),
       [ Opcodes.local_tee, localTmp(scope, '#member_obj') ],
+      ...(scope.locals['#member_obj#type'] ? [
+        ...getNodeType(scope, object),
+        [ Opcodes.local_set, localTmp(scope, '#member_obj#type', Valtype.i32) ],
+      ] : []),
 
       ...nullish(scope, [], getNodeType(scope, object), false, true),
       [ Opcodes.if, Blocktype.void ],
@@ -5695,12 +5752,106 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     out.unshift(
       ...(_objectWasm ? _objectWasm : generate(scope, object)),
       [ Opcodes.local_set, localTmp(scope, '#member_obj') ],
+      ...(scope.locals['#member_obj#type'] ? [
+        ...getNodeType(scope, object),
+        [ Opcodes.local_set, localTmp(scope, '#member_obj#type', Valtype.i32) ],
+      ] : []),
 
       ...generate(scope, property, false, '#member_prop'),
       [ Opcodes.local_set, localTmp(scope, '#member_prop') ]
     );
   }
 
+  if (final.length > 0) {
+    final = final.concat(out);
+    final.push(finalEnd);
+    return final;
+  }
+
+  return out;
+};
+
+const generateClass = (scope, decl) => {
+  const expr = decl.type === 'ClassExpression';
+  if (decl.superClass) return todo(scope, 'class extends is not supported yet', expr);
+
+  const name = decl.id.name;
+  if (name == null) return todo(scope, 'unknown name for class', expr);
+
+  const body = decl.body.body;
+  const root = {
+    type: 'Identifier',
+    name
+  };
+
+  const constr = body.find(x => x.kind === 'constructor')?.value ?? {
+    type: 'FunctionExpression',
+    id: root,
+    params: [],
+    body: {
+      type: 'BlockStatement',
+      body: []
+    }
+  };
+
+  const func = generateFunc(scope, {
+    ...constr,
+    _onlyConstr: `Class constructor ${name} requires 'new'`,
+    type: expr ? 'FunctionExpression' : 'FunctionDeclaration'
+  });
+
+  const out = [];
+
+  for (const x of body) {
+    let { type, key, value, kind, static: _static, computed } = x;
+    if (type !== 'MethodDefinition' && type !== 'PropertyDefinition') return todo(scope, `class body type ${type} is not supported yet`, expr);
+
+    if (kind === 'constructor') continue;
+
+    const object = _static ? root : {
+      type: 'MemberExpression',
+      object: root,
+      property: {
+        type: 'Identifier',
+        name: 'prototype'
+      },
+      computed: false,
+      optional: false
+    };
+
+    let k = key;
+    if (!computed && key.type !== 'Literal') k = {
+      type: 'Literal',
+      value: key.name
+    };
+
+    let initKind = 'init';
+    if (kind === 'get' || kind === 'set') initKind = kind;
+
+    // default value to undefined
+    value ??= DEFAULT_VALUE();
+
+    out.push(
+      ...generate(scope, object),
+      Opcodes.i32_to_u,
+      ...getNodeType(scope, object),
+
+      ...generate(scope, k),
+      ...getNodeType(scope, k),
+      ...toPropertyKey(scope, true),
+
+      ...generate(scope, value),
+      ...(initKind !== 'init' ? [ Opcodes.i32_to_u ] : []),
+      ...getNodeType(scope, value),
+
+      [ Opcodes.call, includeBuiltin(scope, `__Porffor_object_expr_${initKind}`).index ],
+
+      [ Opcodes.drop ],
+      [ Opcodes.drop ]
+    );
+  }
+
+  if (expr) out.push(funcRef(func.index, func.name));
   return out;
 };
 
@@ -5716,7 +5867,9 @@ const objectHack = node => {
       if (node.computed || node.optional) return;
 
       // hack: block these properties as they can be accessed on functions
-      if (node.property.name == 'length' || node.property.name == 'name' || node.property.name == 'call') return;
+      if (node.property.name === 'length' || node.property.name === 'name' || node.property.name === 'call') return;
+
+      if (node.property.name === '__proto__') return;
 
       let objectName = node.object.name;
 
@@ -5914,17 +6067,39 @@ const generateFunc = (scope, decl) => {
     );
   }
 
+  if (decl._onlyConstr) {
+    wasm.unshift(
+      // error if not being constructed
+      [ Opcodes.local_get, '#newtarget' ],
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_eqz ],
+      [ Opcodes.if, Blocktype.void ],
+        ...internalThrow(func, 'TypeError', decl._onlyConstr),
+      [ Opcodes.end ]
+    );
+  }
+
   if (name === 'main') {
     func.gotLastType = true;
     func.export = true;
     func.returns = [ valtypeBinary, Valtype.i32 ];
 
+    let finalStatement = decl.body.body[decl.body.body.length - 1];
+    if (finalStatement?.type === 'EmptyStatement') finalStatement = decl.body.body[decl.body.body.length - 2];
+
     const lastInst = func.wasm[func.wasm.length - 1] ?? [ Opcodes.end ];
     if (lastInst[0] === Opcodes.drop) {
-      func.wasm.splice(func.wasm.length - 1, 1);
-
-      const finalStatement = decl.body.body[decl.body.body.length - 1];
-      func.wasm.push(...getNodeType(func, finalStatement));
+      if (finalStatement.type.endsWith('Declaration')) {
+        // final statement is decl, force undefined
+        disposeLeftover(wasm);
+        func.wasm.push(
+          ...number(UNDEFINED),
+          ...number(TYPES.undefined, Valtype.i32)
+        );
+      } else {
+        func.wasm.splice(func.wasm.length - 1, 1);
+        func.wasm.push(...getNodeType(func, finalStatement));
+      }
     }
 
     if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {

package/compiler/precompile.js

@@ -66,10 +66,7 @@ const compile = async (file, _funcs) => {
   const exports = funcs.filter(x => x.export && x.name !== 'main');
   for (const x of exports) {
     if (x.data) {
-      x.data = x.data.map(x => data[x]);
-      for (const y in x.data) {
-        if (x.data[y].offset != null) x.data[y].offset -= x.data[0].offset;
-      }
+      x.data = x.data.reduce((acc, x) => { acc[data[x].page] = data[x].bytes; return acc; }, {});
     }
 
     if (x.exceptions) {
@@ -226,7 +223,7 @@ ${funcs.map(x => {
 wasm:${rewriteWasm(x.wasm)},
 params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)}` : 'typedReturns:1'},
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},
-${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && x.data.length > 0 ? `data:[${x.data.map(x => `[${x.offset ?? 'null'},[${x.bytes.join(',')}]]`).join(',')}],` : ''}
+${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && Object.keys(x.data).length > 0 ? `data:${JSON.stringify(x.data)},` : ''}
 ${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}
 };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
 }).join('\n')}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.30.14+eb0c07e0b",
+  "version": "0.33.0+0611169e7",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

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