mlogjs 0.4.8 → 0.4.9

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

@@ -283,6 +283,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) {
@@ -545,12 +550,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",
@@ -760,12 +769,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 {
@@ -1249,6 +1286,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 +1328,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;
@@ -1329,7 +1378,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 +1392,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 +1416,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 +1434,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 +1912,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 +1991,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 +2016,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     MemberExpression: MemberExpression,
     ArrayPattern: ArrayPattern,
     ObjectPattern: ObjectPattern,
+    OptionalMemberExpression: OptionalMemberExpression,
     TemplateLiteral: TemplateLiteral,
     BlockStatement: BlockStatement,
     File: File,