porffor 0.58.13 → 0.58.15

package/compiler/codegen.js

@@ -1880,27 +1880,6 @@ const getNodeType = (scope, node) => {
 const generateLiteral = (scope, decl, global, name) => {
   if (decl.value === null) return [ number(NULL) ];
 
-  if (decl.regex) {
-    // 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) {
     case 'number':
       return [ number(decl.value) ];
@@ -1935,6 +1914,27 @@ const generateLiteral = (scope, decl, global, name) => {
       });
   }
 
+  if (decl.regex) {
+    // 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
+        }
+      ]
+    });
+  }
+
   return todo(scope, `cannot generate literal of type ${typeof decl.value}`, true);
 };
 
@@ -5559,7 +5559,11 @@ const compileBytes = (val, itemType) => {
 
 const makeData = (scope, elements, page = null, itemType = 'i8') => {
   // if data for page already exists, abort
-  if (page && data.find(x => x.page === page)) return;
+  if (page) {
+    data.existsForPage ??= new Map();
+    if (data.existsForPage.has(page)) return;
+    data.existsForPage.set(page, true);
+  }
 
   const length = elements.length;
 
@@ -5608,22 +5612,21 @@ const byteStringable = str => {
   return true;
 };
 
-const makeString = (scope, str, forceBytestring = undefined) => {
+const makeString = (scope, str, bytestring = true) => {
   if (str.length === 0) return [ number(0) ];
 
+  if (globalThis.precompile) return [
+    [ 'str', Opcodes.const, str, bytestring ]
+  ];
+
   const elements = new Array(str.length);
-  let bytestring = forceBytestring !== false;
   for (let i = 0; i < str.length; i++) {
     const c = str.charCodeAt(i);
     elements[i] = c;
 
-    if (bytestring && c > 0xFF) bytestring = false;
+    if (c > 0xFF) bytestring = false;
   }
 
-  if (globalThis.precompile) return [
-    [ 'str', Opcodes.const, str, forceBytestring ]
-  ];
-
   const ptr = allocStr({ scope, pages }, str, bytestring);
   makeData(scope, elements, str, bytestring ? 'i8' : 'i16');
 
@@ -6351,13 +6354,6 @@ const generateClass = (scope, decl) => {
   // always generate class constructor funcs
   func.generate();
 
-  let constrInsertIndex = func.wasm.findIndex(x => x.at(-1) === 'super marker');
-  if (constrInsertIndex != -1) {
-    func.wasm.splice(constrInsertIndex, 1);
-  } else {
-    constrInsertIndex = 0;
-  }
-
   if (decl.superClass) {
     const superTmp = localTmp(scope, '#superclass');
     const superTypeTmp = localTmp(scope, '#superclass#type', Valtype.i32);
@@ -6417,10 +6413,15 @@ const generateClass = (scope, decl) => {
     );
   }
 
-  scope.overrideThis = generate(scope, root);
-  scope.overrideThisType = TYPES.function;
+  // opt: avoid mass generate calls for many class fields
+  const rootWasm = scope.overrideThis = generate(scope, root);
+  const rootType = scope.overrideThisType = [ [ Opcodes.i32_const, TYPES.function ] ];
+  const protoWasm = generate(scope, proto);
+  const protoType = getNodeType(scope, proto);
+  const thisWasm = generate(func, { type: 'ThisExpression', _noGlobalThis: true });
+  const thisType = getNodeType(func, { type: 'ThisExpression', _noGlobalThis: true });
 
-  let constrAdd = [];
+  const batchedNonStaticPropWasm = [];
   for (const x of body) {
     let { type, value, kind, static: _static, computed } = x;
     if (kind === 'constructor') continue;
@@ -6441,13 +6442,11 @@ const generateClass = (scope, decl) => {
     }
 
     const key = getProperty(x, true);
-    let object = _static ? root : proto;
-
-    let initKind = type === 'MethodDefinition' ? 'method' : 'value';
-    if (kind === 'get' || kind === 'set') initKind = kind;
 
-    // default value to undefined
-    value ??= DEFAULT_VALUE();
+    value ??= {
+      type: 'Identifier',
+      name: 'undefined'
+    };
 
     if (isFuncType(value.type)) {
       let id = value.id;
@@ -6468,51 +6467,53 @@ const generateClass = (scope, decl) => {
 
     if (type === 'PropertyDefinition' && !_static) {
       // define in construction instead
-      object = {
-        type: 'ThisExpression',
-        _noGlobalThis: true
-      };
-
-      let computedTmp;
       if (computed) {
-        // compute now, reference in construction
-        computedTmp = allocVar(scope, `#class_computed_prop${uniqId()}`, true, true, false, true);
+        // compute key now, reference in construction
+        const computedTmp = allocVar(scope, `#class_computed_prop${uniqId()}`, true, true, false, true);
 
         out.push(
           ...toPropertyKey(scope, generate(scope, key), getNodeType(scope, key), computed, true),
           [ Opcodes.global_set, computedTmp + 1 ],
           [ Opcodes.global_set, computedTmp ]
         );
-      }
 
-      const constrWasm = [
-        ...generate(func, object),
-        Opcodes.i32_to_u,
-        ...getNodeType(func, object),
+        batchedNonStaticPropWasm.push(
+          ...thisWasm,
+          Opcodes.i32_to_u,
+          ...thisType,
 
-        ...(computed ? [
           [ Opcodes.global_get, computedTmp ],
           [ Opcodes.global_get, computedTmp + 1 ],
-        ] : [
-          ...generate(func, key),
+
+          ...generate(func, value),
+          ...getNodeType(func, value),
+
+          [ Opcodes.call, includeBuiltin(func, `__Porffor_object_class_value`).index ]
+        );
+      } else {
+        batchedNonStaticPropWasm.push(
+          ...thisWasm,
           Opcodes.i32_to_u,
-          ...getNodeType(func, key)
-        ]),
+          ...thisType,
 
-        ...generate(func, value),
-        ...(initKind !== 'value' && initKind !== 'method' ? [ Opcodes.i32_to_u ] : []),
-        ...getNodeType(func, value),
+          ...generate(func, key),
+          Opcodes.i32_to_u,
+          ...getNodeType(func, key),
 
-        [ Opcodes.call, includeBuiltin(func, `__Porffor_object_class_${initKind}`).index ]
-      ];
+          ...generate(func, value),
+          ...getNodeType(func, value),
 
-      func.wasm.splice(constrInsertIndex, 0, ...constrWasm);
-      constrInsertIndex += constrWasm.length;
+          [ Opcodes.call, includeBuiltin(func, `__Porffor_object_class_value`).index ]
+        );
+      }
     } else {
+      let initKind = type === 'MethodDefinition' ? 'method' : 'value';
+      if (kind === 'get' || kind === 'set') initKind = kind;
+
       out.push(
-        ...generate(scope, object),
+        ...(_static ? rootWasm : protoWasm),
         Opcodes.i32_to_u,
-        ...getNodeType(scope, object),
+        ...(_static ? rootType : protoType),
 
         ...toPropertyKey(scope, generate(scope, key), getNodeType(scope, key), computed, true),
 
@@ -6525,6 +6526,14 @@ const generateClass = (scope, decl) => {
     }
   }
 
+  const constrInsertIndex = func.wasm.findIndex(x => x.at(-1) === 'super marker');
+  if (constrInsertIndex != -1) {
+    func.wasm.splice(constrInsertIndex, 1);
+    func.wasm.splice(constrInsertIndex, 0, ...batchedNonStaticPropWasm);
+  } else {
+    func.wasm = batchedNonStaticPropWasm.concat(func.wasm);
+  }
+
   delete scope.overrideThis;
   delete scope.overrideThisType;