mlogjs 0.4.8 → 0.4.10

package/dist/Compiler.d.ts

@@ -1,6 +1,6 @@
 import { CompilerError } from "./CompilerError";
 import { es, IScope, IValue, TEOutput, THandler, TValueInstructions } from "./types";
-declare type THandlerMap = {
+type THandlerMap = {
     [k in es.Node["type"]]?: THandler<IValue | null>;
 };
 export interface CompilerOptions {

package/dist/CompilerError.d.ts

@@ -12,7 +12,7 @@ export interface ParsingError extends Error {
         column: number;
     };
 }
-declare type CompilerErrorSource = es.Node | es.SourceLocation | {
+type CompilerErrorSource = es.Node | es.SourceLocation | {
     line: number;
     column: number;
 };

package/dist/Scope.d.ts

@@ -7,12 +7,14 @@ export declare class Scope implements IScope {
     ntemp: number;
     name: string;
     inst: IInstruction[];
+    operationCache: Record<string, IValue>;
+    cacheDependencies: Record<string, string[]>;
     data: Record<string, IValue | null>;
     break: AddressResolver;
     continue: AddressResolver;
     function: IFunctionValue;
     label?: string;
-    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
+    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[], operationCache?: Record<string, IValue>, cacheDependencies?: Record<string, string[]>);
     copy(): IScope;
     createScope(): IScope;
     createFunction(name: string, stacked?: boolean): IScope;
@@ -22,4 +24,7 @@ export declare class Scope implements IScope {
     hardSet<T extends IValue>(name: string, value: T): T;
     make(identifier: string, name: string): SenseableValue;
     makeTempName(): string;
+    addCachedOperation(op: string, result: IValue, left: IValue, right?: IValue | undefined): void;
+    getCachedOperation(op: string, left: IValue, right?: IValue | undefined): IValue | undefined;
+    clearDependentCache(value: IValue): void;
 }

package/dist/handlers/Object.d.ts

@@ -1,6 +1,7 @@
-import { THandler } from "../types";
+import { IValue, THandler } from "../types";
 export declare const ObjectExpression: THandler;
 export declare const ArrayExpression: THandler;
 export declare const MemberExpression: THandler;
 export declare const ArrayPattern: THandler;
 export declare const ObjectPattern: THandler;
+export declare const OptionalMemberExpression: THandler<IValue>;

package/dist/handlers/OperationExpressions.d.ts

@@ -6,3 +6,4 @@ export declare const AssignmentExpression: THandler;
 export declare const UnaryExpression: THandler;
 export declare const UpdateExpression: THandler;
 export declare const ConditionalExpression: THandler;
+export declare const SequenceExpression: THandler;

package/dist/handlers/Statements.d.ts

@@ -3,4 +3,5 @@ export declare const ExpressionStatement: THandler<IValue | null>;
 export declare const BreakStatement: THandler<null>;
 export declare const ContinueStatement: THandler<null>;
 export declare const ReturnStatement: THandler<IValue | null>;
+export declare const EmptyStatement: THandler<null>;
 export declare const LabeledStatement: THandler<null>;

package/dist/index.cjs

@@ -167,7 +167,19 @@ const unaryOperators = [
 ];
 const updateOperators = ["++", "--"];
 const singleOperators = [...unaryOperators, ...updateOperators];
-const operators = [...leftRightOperators, ...singleOperators];
+const operators = [...leftRightOperators, ...singleOperators];
+const orderIndependentOperators = [
+    "!=",
+    "!==",
+    "&&",
+    "&",
+    "*",
+    "+",
+    "==",
+    "===",
+    "|",
+    "||",
+];
 
 class VoidValue {
     constructor() {
@@ -198,18 +210,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(" ");
@@ -283,6 +295,11 @@ function camelToDashCase(name) {
 // eslint-disable-next-line @typescript-eslint/ban-types
 function assign(obj, props) {
     return Object.assign(obj, props);
+}
+/** Lazily computes and caches an expression */
+function lazy(fn) {
+    let value;
+    return () => (value ??= fn());
 }
 
 function appendSourceLocations(valueInst, node) {
@@ -422,14 +439,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;
@@ -545,12 +562,16 @@ class BaseValue extends VoidValue {
             ],
         ];
     }
+    "!=="(scope, other, out) {
+        const [equal, equalInst] = this["==="](scope, other);
+        const [result, resultInst] = equal["!"](scope, out);
+        return [result, [...equalInst, ...resultInst]];
+    }
 }
 const operatorMap$1 = {
     "==": "equal",
     "===": "strictEqual",
     "!=": "notEqual",
-    "!==": "notEqual",
     "<": "lessThan",
     ">": "greaterThan",
     "<=": "lessThanEq",
@@ -637,6 +658,7 @@ class LiteralValue extends BaseValue {
         super();
         this.mutability = EMutability.constant;
         this.data = data;
+        this.name = this.toString();
     }
     eval(_scope) {
         return [this, []];
@@ -760,12 +782,40 @@ class StoreValue extends BaseValue {
         const [evalValue, evalInst] = value.eval(scope, this);
         return [this, [...evalInst, new SetInstruction(this, evalValue)]];
     }
+    "=="(scope, value, out) {
+        if (compareStores(this, value))
+            return [new LiteralValue(1), []];
+        return super["=="](scope, value, out);
+    }
+    "==="(scope, value, out) {
+        if (compareStores(this, value))
+            return [new LiteralValue(1), []];
+        return super["==="](scope, value, out);
+    }
+    "!="(scope, value, out) {
+        if (compareStores(this, value))
+            return [new LiteralValue(0), []];
+        return super["!="](scope, value, out);
+    }
+    "!=="(scope, value, out) {
+        if (compareStores(this, value))
+            return [new LiteralValue(0), []];
+        return super["!=="](scope, value, out);
+    }
     eval(_scope) {
         return [this, []];
     }
     toString() {
         return this.name;
     }
+}
+function compareStores(left, right) {
+    return (left === right ||
+        // prevents a store from being equal to a senseable value
+        (right instanceof left.constructor &&
+            right.mutability === EMutability.constant &&
+            left.mutability === EMutability.constant &&
+            right.name === left.name));
 }
 
 class ObjectValue extends VoidValue {
@@ -947,16 +997,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;
@@ -965,6 +1017,8 @@ class Scope {
     createScope() {
         const scope = this.copy();
         scope.data = {};
+        scope.operationCache = {};
+        scope.cacheDependencies = {};
         scope.parent = this;
         return scope;
     }
@@ -1010,6 +1064,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) => {
@@ -1185,7 +1279,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;
@@ -1207,18 +1315,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]];
@@ -1249,6 +1365,17 @@ const ConditionalExpression = (c, scope, node, out) => {
             new AddressResolver(endExpressionAdress),
         ],
     ];
+};
+const SequenceExpression = (c, scope, node, out) => {
+    const { expressions } = node;
+    const inst = [];
+    // compute every expression except the last one
+    for (let i = 0; i < expressions.length - 1; i++) {
+        const [, exprInst] = c.handleEval(scope, expressions[i], discardedName);
+        inst.push(...exprInst);
+    }
+    const [value, valueInst] = c.handleEval(scope, expressions[expressions.length - 1], out);
+    return [value, [...inst, ...valueInst]];
 };
 
 const Identifier = (c, scope, node) => {
@@ -1280,6 +1407,7 @@ const ReturnStatement = (c, scope, node, out) => {
     const [ret, retInst] = scope.function.return(scope, arg, out);
     return [ret, [...argInst, ...retInst]];
 };
+const EmptyStatement = () => [null, []];
 const LabeledStatement = (c, scope, node) => {
     const inner = scope.createScope();
     inner.label = node.label.name;
@@ -1309,9 +1437,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];
@@ -1329,7 +1460,7 @@ const SwitchStatement = (c, scope, node) => {
     let constantCase = false;
     let onlyConstantTests = true;
     for (const scase of node.cases) {
-        const [, bodyInst] = c.handleMany(innerScope, scase.consequent);
+        const bodyInst = lazy(() => c.handleMany(innerScope, scase.consequent)[1]);
         const bodyAdress = new LiteralValue(null);
         const bodyLine = new AddressResolver(bodyAdress);
         const canFallInto = !endsWithoutFalltrough(inst, endLine);
@@ -1343,7 +1474,7 @@ const SwitchStatement = (c, scope, node) => {
                 ])[1];
             }
             if (includeBody)
-                inst.push(bodyLine, ...bodyInst);
+                inst.push(bodyLine, ...bodyInst());
             continue;
         }
         const [test, testInst] = c.handleEval(innerScope, scase.test);
@@ -1367,8 +1498,8 @@ const SwitchStatement = (c, scope, node) => {
                 // and all the other cases will never run
                 if (noFallInto &&
                     onlyConstantTests &&
-                    endsWithoutFalltrough(bodyInst, endLine)) {
-                    return [null, [...bodyInst, endLine]];
+                    endsWithoutFalltrough(bodyInst(), endLine)) {
+                    return [null, [...bodyInst(), endLine]];
                 }
                 jump = c.handle(innerScope, scase, () => [
                     null,
@@ -1385,7 +1516,7 @@ const SwitchStatement = (c, scope, node) => {
         if (includeJump)
             caseJumps.push(...testInst, ...jump);
         if (includeBody)
-            inst.push(bodyLine, ...bodyInst);
+            inst.push(bodyLine, ...bodyInst());
     }
     // ensures that the processor exits
     // the switch if no cases match
@@ -1863,7 +1994,9 @@ const ObjectPattern = (c, scope, node) => {
         });
     }
     return [new DestructuringValue(members), inst];
-};
+};
+// the mlog runtime already does this check for us
+const OptionalMemberExpression = MemberExpression;
 
 const TemplateLiteral = () => {
     throw new CompilerError("Template strings are currently unavailable. To inline mlog code use the asm function.");
@@ -1940,11 +2073,13 @@ var handlers = /*#__PURE__*/Object.freeze({
     UnaryExpression: UnaryExpression,
     UpdateExpression: UpdateExpression,
     ConditionalExpression: ConditionalExpression,
+    SequenceExpression: SequenceExpression,
     Identifier: Identifier,
     ExpressionStatement: ExpressionStatement,
     BreakStatement: BreakStatement,
     ContinueStatement: ContinueStatement,
     ReturnStatement: ReturnStatement,
+    EmptyStatement: EmptyStatement,
     LabeledStatement: LabeledStatement,
     IfStatement: IfStatement,
     SwitchStatement: SwitchStatement,
@@ -1963,6 +2098,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     MemberExpression: MemberExpression,
     ArrayPattern: ArrayPattern,
     ObjectPattern: ObjectPattern,
+    OptionalMemberExpression: OptionalMemberExpression,
     TemplateLiteral: TemplateLiteral,
     BlockStatement: BlockStatement,
     File: File,
@@ -2010,6 +2146,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),
@@ -2026,7 +2163,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) {
@@ -2034,8 +2181,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;