mlogjs 0.4.7 → 0.4.9

package/dist/index.mjs

@@ -262,6 +262,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) {
@@ -524,12 +529,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",
@@ -739,12 +748,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 {
@@ -1228,6 +1265,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) => {
@@ -1259,6 +1307,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;
@@ -1304,38 +1353,67 @@ const SwitchStatement = (c, scope, node) => {
     const endLine = new AddressResolver(endAdress).bindBreak(innerScope);
     const caseJumps = [];
     let defaultJump;
+    // if there is a case that is guaranteed to run
+    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);
+        let includeJump = !constantCase;
+        const includeBody = !constantCase || canFallInto;
         if (!scase.test) {
-            [defaultJump] = c.handle(innerScope, scase, () => [
-                null,
-                [new JumpInstruction(bodyAdress, EJumpKind.Always)],
-            ])[1];
-            inst.push(bodyLine, ...bodyInst);
+            if (includeJump) {
+                [defaultJump] = c.handle(innerScope, scase, () => [
+                    null,
+                    [new JumpInstruction(bodyAdress, EJumpKind.Always)],
+                ])[1];
+            }
+            if (includeBody)
+                inst.push(bodyLine, ...bodyInst());
             continue;
         }
         const [test, testInst] = c.handleEval(innerScope, scase.test);
+        if (onlyConstantTests)
+            onlyConstantTests = test.mutability === EMutability.constant;
+        let jump;
         // check if it can be evaluated at compile time
-        const [comp] = ref["=="](innerScope, test);
-        // if the constant expression resolves to false
-        // the whole case gets omitted
-        // otherwise it returns the instructions for
-        // the body of this case
+        // the scope copy prevents unecessary increases in the temp counter
+        const [comp] = ref["=="](innerScope.copy(), test);
         if (comp instanceof LiteralValue) {
-            if (comp.data)
-                return [null, bodyInst];
-            else
-                continue;
+            // whether other cases can falltrough and reach this one
+            const noFallInto = !canFallInto;
+            if (!comp.data) {
+                // this case is not accessible in any way
+                if (noFallInto)
+                    continue;
+                includeJump = false;
+            }
+            else {
+                // this case is only accessible via the comparison jump
+                // and all the other cases will never run
+                if (noFallInto &&
+                    onlyConstantTests &&
+                    endsWithoutFalltrough(bodyInst(), endLine)) {
+                    return [null, [...bodyInst(), endLine]];
+                }
+                jump = c.handle(innerScope, scase, () => [
+                    null,
+                    [new JumpInstruction(bodyAdress, EJumpKind.Always)],
+                ])[1];
+                constantCase = true;
+            }
         }
         // makes sourcemapping for the jump more specific
-        const [, jump] = c.handle(innerScope, scase, () => [
+        jump ??= c.handle(innerScope, scase, () => [
             null,
             [new JumpInstruction(bodyAdress, EJumpKind.StrictEqual, ref, test)],
-        ]);
-        caseJumps.push(...testInst, ...jump);
-        inst.push(bodyLine, ...bodyInst);
+        ])[1];
+        if (includeJump)
+            caseJumps.push(...testInst, ...jump);
+        if (includeBody)
+            inst.push(bodyLine, ...bodyInst());
     }
     // ensures that the processor exits
     // the switch if no cases match
@@ -1350,12 +1428,34 @@ const SwitchStatement = (c, scope, node) => {
         [
             ...refInst,
             ...caseJumps,
-            ...(caseJumps.length > 0 ? [defaultJump] : []),
+            ...(caseJumps.length > 0 && !constantCase ? [defaultJump] : []),
             ...inst,
             endLine,
         ],
     ];
-};
+};
+function endsWithoutFalltrough(inst, endLine) {
+    if (inst.length === 0)
+        return true;
+    for (let i = inst.length - 1; i >= 0; i--) {
+        const instruction = inst[i];
+        // this means that there is an instruction trying to reference
+        // the final function `set @counter` instruction
+        // of course this generates an unecessary
+        // `set @counter` in cases where a control flow
+        // structure contains a fallback return statement
+        // TODO: fix this with static analysis
+        if (instruction instanceof AddressResolver)
+            return false;
+        if (instruction.hidden)
+            continue;
+        return (instruction instanceof SetCounterInstruction ||
+            instruction.intent === EInstIntent.return ||
+            (instruction instanceof BreakInstruction &&
+                endLine.bonds.includes(instruction.address)));
+    }
+    return false;
+}
 
 const WhileStatement = (c, scope, node) => {
     const lines = [];
@@ -1791,7 +1891,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.");
@@ -1868,11 +1970,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,
@@ -1891,6 +1995,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     MemberExpression: MemberExpression,
     ArrayPattern: ArrayPattern,
     ObjectPattern: ObjectPattern,
+    OptionalMemberExpression: OptionalMemberExpression,
     TemplateLiteral: TemplateLiteral,
     BlockStatement: BlockStatement,
     File: File,