mlogjs 0.4.9 → 0.4.10

package/dist/index.mjs

@@ -146,7 +146,19 @@ const unaryOperators = [
 ];
 const updateOperators = ["++", "--"];
 const singleOperators = [...unaryOperators, ...updateOperators];
-const operators = [...leftRightOperators, ...singleOperators];
+const operators = [...leftRightOperators, ...singleOperators];
+const orderIndependentOperators = [
+    "!=",
+    "!==",
+    "&&",
+    "&",
+    "*",
+    "+",
+    "==",
+    "===",
+    "|",
+    "||",
+];
 
 class VoidValue {
     constructor() {
@@ -177,18 +189,18 @@ for (const key of operators) {
 }
 
 class InstructionBase {
-    constructor(...args) {
-        this.intent = EInstIntent.none;
-        this.alwaysRuns = true;
-        this._hidden = false;
-        this.args = args;
-    }
     get hidden() {
         return this._hidden;
     }
     set hidden(value) {
         this._hidden = value;
     }
+    constructor(...args) {
+        this.intent = EInstIntent.none;
+        this.alwaysRuns = true;
+        this._hidden = false;
+        this.args = args;
+    }
     resolve(_i) { }
     toString() {
         return this.args.filter(arg => arg).join(" ");
@@ -406,14 +418,14 @@ class EndInstruction extends InstructionBase {
 }
 
 class AddressResolver extends InstructionBase {
-    constructor(...bonds) {
-        super();
-        this.bonds = bonds;
-    }
     get hidden() {
         return true;
     }
     set hidden(value) { }
+    constructor(...bonds) {
+        super();
+        this.bonds = bonds;
+    }
     resolve(i) {
         for (const literal of this.bonds)
             literal.data = i;
@@ -625,6 +637,7 @@ class LiteralValue extends BaseValue {
         super();
         this.mutability = EMutability.constant;
         this.data = data;
+        this.name = this.toString();
     }
     eval(_scope) {
         return [this, []];
@@ -963,16 +976,18 @@ class LazyValue extends VoidValue {
 }
 
 class Scope {
-    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = []) {
+    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = [], operationCache = {}, cacheDependencies = {}) {
         this.parent = parent;
         this.stacked = stacked;
         this.ntemp = ntemp;
         this.name = name;
         this.inst = inst;
+        this.operationCache = operationCache;
+        this.cacheDependencies = cacheDependencies;
         this.data = values;
     }
     copy() {
-        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst);
+        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst, { ...this.operationCache }, { ...this.cacheDependencies });
         scope.break = this.break;
         scope.continue = this.continue;
         scope.function = this.function;
@@ -981,6 +996,8 @@ class Scope {
     createScope() {
         const scope = this.copy();
         scope.data = {};
+        scope.operationCache = {};
+        scope.cacheDependencies = {};
         scope.parent = this;
         return scope;
     }
@@ -1026,6 +1043,46 @@ class Scope {
         this.ntemp++;
         return result;
     }
+    addCachedOperation(op, result, left, right) {
+        if (!left.name || !result.name || (right && !right.name))
+            return;
+        const id = formatCacheId(op, left, right);
+        this.operationCache[id] = result;
+        this.clearDependentCache(result);
+        addCacheDependency(this, left.name, id);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (right)
+            addCacheDependency(this, right.name, id);
+        addCacheDependency(this, result.name, id);
+    }
+    getCachedOperation(op, left, right) {
+        const id = formatCacheId(op, left, right);
+        const result = this.operationCache[id];
+        if (result)
+            return result;
+        if (this.parent)
+            return this.parent.getCachedOperation(op, left, right);
+    }
+    clearDependentCache(value) {
+        if (!value.name)
+            return;
+        const dependents = this.cacheDependencies[value.name];
+        if (dependents) {
+            for (const id of dependents) {
+                delete this.operationCache[id];
+            }
+        }
+        if (this.parent)
+            this.parent.clearDependentCache(value);
+    }
+}
+function formatCacheId(op, left, right) {
+    if (right)
+        return `{${op}}{${left.name}}{${right.name}}`;
+    return `{${op}}{${left.name}}`;
+}
+function addCacheDependency(scope, name, id) {
+    (scope.cacheDependencies[name] ??= []).push(id);
 }
 
 const Program = (c, scope, node) => {
@@ -1201,7 +1258,21 @@ const BooleanLiteral = (_c, scope, node) => [new LiteralValue(+node.value), []];
 const LRExpression = (c, scope, node, out) => {
     const [left, leftInst] = c.handleEval(scope, node.left);
     const [right, rightInst] = c.handleEval(scope, node.right);
+    if (!(left instanceof LiteralValue) || !(right instanceof LiteralValue)) {
+        const cachedResult = scope.getCachedOperation(node.operator, left, right);
+        if (cachedResult)
+            return [cachedResult, [...leftInst, ...rightInst]];
+        // because a * b is the same as b * a
+        if (orderIndependentOperators.includes(node.operator)) {
+            const cachedResult = scope.getCachedOperation(node.operator, right, left);
+            if (cachedResult)
+                return [cachedResult, [...leftInst, ...rightInst]];
+        }
+    }
     const [op, opInst] = left[node.operator](scope, right, out);
+    if (!(op instanceof LiteralValue)) {
+        scope.addCachedOperation(node.operator, op, left, right);
+    }
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const BinaryExpression = LRExpression;
@@ -1223,18 +1294,26 @@ const AssignmentExpression = (c, scope, node) => {
         ];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
+    if (left)
+        scope.clearDependentCache(left);
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const UnaryExpression = (c, scope, { argument, operator }, out) => {
     const [arg, argInst] = c.handleEval(scope, argument);
+    const cachedResult = scope.getCachedOperation(operator, arg);
+    if (cachedResult)
+        return [cachedResult, argInst];
     const operatorId = operator == "+" || operator == "-" ? `u${operator}` : operator;
     if (operatorId === "throw")
         throw new CompilerError("throw operator is not supported");
     const [op, opInst] = arg[operatorId](scope, out);
+    scope.addCachedOperation(operator, op, arg);
     return [op, [...argInst, ...opInst]];
 };
 const UpdateExpression = (c, scope, { argument, operator, prefix }, out) => {
     const [arg, argInst] = c.handle(scope, argument);
+    if (arg)
+        scope.clearDependentCache(arg);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = arg[operator](scope, prefix, out);
     return [op, [...argInst, ...opInst]];
@@ -1337,9 +1416,12 @@ const IfStatement = (c, scope, node) => {
         return [null, inst];
     }
     const endIfAddr = new LiteralValue(null);
-    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1], new AddressResolver(endIfAddr));
-    const endElseAddr = new LiteralValue(null);
-    if (node.alternate) {
+    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1]);
+    if (!node.alternate) {
+        inst.push(new AddressResolver(endIfAddr));
+    }
+    else {
+        const endElseAddr = new LiteralValue(null);
         inst.push(new JumpInstruction(endElseAddr, EJumpKind.Always), new AddressResolver(endIfAddr), ...withAlwaysRuns(c.handle(scope, node.alternate), false)[1], new AddressResolver(endElseAddr));
     }
     return [null, inst];
@@ -2043,6 +2125,7 @@ const mathOperations = {
     sqrt: a => Math.sqrt(a),
     rand: null,
 };
+const orderIndependentOperations = ["max", "min", "len"];
 function createMacroMathOperations() {
     const macroMathOperations = {
         PI: new StoreValue("@pi", EMutability.constant),
@@ -2059,7 +2142,17 @@ function createMacroMathOperations() {
                         throw new CompilerError("Cannot do math operation with non-numerical literals.");
                     return [new LiteralValue(fn(a.num, b.num)), []];
                 }
+                const cachedResult = scope.getCachedOperation(key, a, b);
+                if (cachedResult)
+                    return [cachedResult, []];
+                // max, min and len do not change if the arguments change in order
+                if (orderIndependentOperations.includes(key)) {
+                    const cachedResult = scope.getCachedOperation(key, b, a);
+                    if (cachedResult)
+                        return [cachedResult, []];
+                }
                 const temp = StoreValue.from(scope, out);
+                scope.addCachedOperation(key, temp, a, b);
                 return [temp, [new OperationInstruction(key, temp, a, b)]];
             }
             if (fn && a instanceof LiteralValue) {
@@ -2067,8 +2160,14 @@ function createMacroMathOperations() {
                     throw new CompilerError("Cannot do math operation with non-numerical literal.");
                 return [new LiteralValue(fn(a.num)), []];
             }
+            const cachedResult = scope.getCachedOperation(key, a);
+            if (cachedResult)
+                return [cachedResult, []];
             const temp = StoreValue.from(scope, out);
-            return [temp, [new OperationInstruction(key, temp, a, b)]];
+            // ensures that operations like `rand` are not cached
+            if (mathOperations[key])
+                scope.addCachedOperation(key, temp, a);
+            return [temp, [new OperationInstruction(key, temp, a, null)]];
         });
     }
     return macroMathOperations;