mlogjs 0.4.0 → 0.4.2

package/dist/index.mjs

@@ -114,7 +114,7 @@ const arithmeticAssignmentOperators = [
     "-=",
     "/=",
 ];
-const logicalAssignmentOperators = ["&&=", "||="];
+const logicalAssignmentOperators = ["&&=", "||=", "??="];
 const bitwiseAssignmentOperators = [
     "<<=",
     ">>=",
@@ -147,11 +147,10 @@ const singleOperators = [...unaryOperators, ...updateOperators];
 const operators = [...leftRightOperators, ...singleOperators];
 
 class VoidValue {
-    constructor(scope) {
+    constructor() {
         this.owner = null;
         this.mutability = EMutability.mutable;
         this.macro = false;
-        this.scope = scope;
     }
     eval(_scope) {
         throw new CompilerError(`${this} cannot eval.`);
@@ -208,8 +207,22 @@ class SetInstruction extends InstructionBase {
     constructor(store, value) {
         super("set", store, value);
     }
+    get store() {
+        return this.args[1];
+    }
+    get value() {
+        return this.args[2];
+    }
     get hidden() {
-        return this._hidden || !this.args[1].owner;
+        const { store, value } = this;
+        return (this._hidden ||
+            // assignment to discarded value
+            !store.owner ||
+            // self assignment of a store
+            (!!store.owner &&
+                store instanceof StoreValue &&
+                value instanceof StoreValue &&
+                store.owner === value.owner));
     }
 }
 
@@ -288,38 +301,6 @@ class ContinueInstruction extends JumpInstruction {
     }
 }
 
-class ValueOwner {
-    /**
-     * Creates a new `ValueOwner`, if `value` is already owned,
-     * `this` will be aliased to `value`, else `this` will own `value`
-     */
-    constructor({ scope, constant = false, value, identifier, name, }) {
-        this.scope = scope;
-        this.constant = constant;
-        this.value = value;
-        this.identifier = identifier;
-        this.name = name ?? scope.makeTempName();
-        this.persistent = !!name;
-        this.owned = new Set();
-        if (!value.owner?.persistent)
-            this.own(value);
-    }
-    own(target) {
-        target.owner = this;
-        this.owned.add(target);
-    }
-    replace(target) {
-        this.value.owner = null;
-        this.owned.delete(this.value);
-        this.value = target;
-        this.own(target);
-    }
-    moveInto(owner) {
-        this.owned.forEach(value => owner.own(value));
-        this.owned.clear();
-    }
-}
-
 class BaseValue extends VoidValue {
     "u-"(scope) {
         const [that, inst] = this.consume(scope);
@@ -328,7 +309,7 @@ class BaseValue extends VoidValue {
             temp,
             [
                 ...inst,
-                new OperationInstruction("sub", temp, new LiteralValue(scope, 0), that),
+                new OperationInstruction("sub", temp, new LiteralValue(0), that),
             ],
         ];
     }
@@ -339,7 +320,7 @@ class BaseValue extends VoidValue {
     "!"(scope) {
         const [that, inst] = this.consume(scope);
         const temp = new StoreValue(scope);
-        const falseLiteral = new LiteralValue(scope, 0);
+        const falseLiteral = new LiteralValue(0);
         return [
             temp,
             [...inst, new OperationInstruction("equal", temp, that, falseLiteral)],
@@ -350,8 +331,33 @@ class BaseValue extends VoidValue {
         const temp = new StoreValue(scope);
         return [temp, [...inst, new OperationInstruction("not", temp, that, null)]];
     }
-    ensureOwned() {
-        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    // requires special handling
+    // the handler should give an object value to allow the lazy evaluation
+    "??"(scope, other) {
+        const [left, leftInst] = this.eval(scope);
+        const nullLiteral = new LiteralValue(null);
+        const endAdress = new LiteralValue(null);
+        const [nullTest] = left["=="](scope, nullLiteral);
+        if (nullTest instanceof LiteralValue) {
+            if (nullTest.data)
+                return other.eval(scope);
+            else
+                return [left, leftInst];
+        }
+        const [right, rightInst] = other.eval(scope);
+        const result = new StoreValue(scope);
+        result.ensureOwned();
+        return [
+            result,
+            [
+                ...leftInst,
+                ...result["="](scope, left)[1],
+                new JumpInstruction(endAdress, EJumpKind.NotEqual, result, nullLiteral),
+                ...rightInst,
+                ...result["="](scope, right)[1],
+                new AddressResolver(endAdress),
+            ],
+        ];
     }
 }
 const operatorMap$1 = {
@@ -409,6 +415,7 @@ const assignmentToBinary = {
     "<<=": "<<",
     "&&=": "&&",
     "||=": "||",
+    "??=": "??",
 };
 for (const op in assignmentToBinary) {
     BaseValue.prototype[op] = function (scope, value) {
@@ -428,23 +435,20 @@ for (const key of updateOperators) {
             inst.push(...tempInst);
         }
         const kind = key === "++" ? "+=" : "-=";
-        return [
-            ret,
-            [...inst, ...this[kind](scope, new LiteralValue(scope, 1))[1]],
-        ];
+        return [ret, [...inst, ...this[kind](scope, new LiteralValue(1))[1]]];
     };
 }
 
 const literalMethods = {
-    length: function (scope) {
+    length: function () {
         if (typeof this.data !== "string")
             throw new CompilerError("Length method only works on string literal values.");
-        return new LiteralValue(scope, this.data.length);
+        return new LiteralValue(this.data.length);
     },
 };
 class LiteralValue extends BaseValue {
-    constructor(scope, data) {
-        super(scope);
+    constructor(data) {
+        super();
         this.mutability = EMutability.constant;
         this.data = data;
     }
@@ -472,9 +476,10 @@ class LiteralValue extends BaseValue {
             return 1;
         return this.data;
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "literal"), []];
+    typeof() {
+        return [new LiteralValue("literal"), []];
     }
+    ensureOwned() { }
 }
 const operatorMap = {
     "==": (a, b) => +(a == b),
@@ -506,10 +511,7 @@ for (const key in operatorMap) {
         if (!(value instanceof LiteralValue)) {
             return BaseValue.prototype[key].apply(this, [scope, value]);
         }
-        return [
-            new LiteralValue(scope, fn(this.data, value.data)),
-            [],
-        ];
+        return [new LiteralValue(fn(this.data, value.data)), []];
     };
 }
 const unaryOperatorMap = {
@@ -519,9 +521,9 @@ const unaryOperatorMap = {
     "u+": v => +v,
 };
 for (const key in unaryOperatorMap) {
-    LiteralValue.prototype[key] = function (scope) {
+    LiteralValue.prototype[key] = function () {
         const fn = unaryOperatorMap[key];
-        return [new LiteralValue(scope, fn(this.data)), []];
+        return [new LiteralValue(fn(this.data)), []];
     };
 }
 
@@ -600,17 +602,50 @@ function isTemplateObjectArray(value) {
         typeof value.data.raw.data.length.data === "number");
 }
 
+class ValueOwner {
+    /**
+     * Creates a new `ValueOwner`, if `value` is already owned,
+     * `this` will be aliased to `value`, else `this` will own `value`
+     */
+    constructor({ scope, constant = false, value, identifier, name, }) {
+        this.scope = scope;
+        this.constant = constant;
+        this.value = value;
+        this.identifier = identifier;
+        this.name = name ?? scope.makeTempName();
+        this.persistent = !!name;
+        this.owned = new Set();
+        if (!value.owner?.persistent)
+            this.own(value);
+    }
+    own(target) {
+        target.owner = this;
+        this.owned.add(target);
+    }
+    replace(target) {
+        this.value.owner = null;
+        this.owned.delete(this.value);
+        this.value = target;
+        this.own(target);
+    }
+    moveInto(owner) {
+        this.owned.forEach(value => owner.own(value));
+        this.owned.clear();
+    }
+}
+
 /**
  * `StoreValue` represents values unknown at compile time,
  * mostly used with mutable variables and temporary values
  */
 class StoreValue extends BaseValue {
     constructor(scope) {
-        super(scope);
+        super();
+        this.scope = scope;
         this.mutability = EMutability.mutable;
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "store"), []];
+    typeof() {
+        return [new LiteralValue("store"), []];
     }
     "="(scope, value) {
         if (this.mutability !== EMutability.mutable)
@@ -637,31 +672,34 @@ class StoreValue extends BaseValue {
         this.ensureOwned();
         return [this, []];
     }
+    ensureOwned() {
+        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    }
     toString() {
         return this.owner?.name ?? discardedName;
     }
 }
 
 class ObjectValue extends VoidValue {
-    constructor(scope, data = {}) {
-        super(scope);
+    constructor(data = {}) {
+        super();
         this.mutability = EMutability.constant;
         this.macro = true;
         this.data = data;
     }
-    static fromArray(scope, items, intialData) {
+    static fromArray(items, intialData) {
         const data = {
             ...intialData,
-            length: new LiteralValue(scope, items.length),
+            length: new LiteralValue(items.length),
         };
         items.forEach((item, i) => {
             if (item)
                 data[i] = item;
         });
-        return new ObjectValue(scope, data);
+        return new ObjectValue(data);
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "object"), []];
+    typeof() {
+        return [new LiteralValue("object"), []];
     }
     get(scope, key) {
         // avoids naming collisions with keys like
@@ -698,9 +736,7 @@ class ObjectValue extends VoidValue {
             return super.call(scope, args);
         return $call.call(scope, args);
     }
-    ensureOwned() {
-        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
-    }
+    ensureOwned() { }
 }
 for (const op of operators) {
     ObjectValue.prototype[op] = function (...args) {
@@ -769,8 +805,8 @@ class SenseableValue extends StoreValue {
  * each of them to their counterparts on the right hand value.
  */
 class DestructuringValue extends VoidValue {
-    constructor(scope, members) {
-        super(scope);
+    constructor(members) {
+        super();
         this.members = members;
         this.macro = true;
     }
@@ -957,7 +993,7 @@ const DeclareObjectPattern = (c, scope, node, kind, base) => {
             throw new CompilerError("The rest operator is not supported", prop);
         const { key, value } = prop;
         const keyInst = key.type === "Identifier" && !prop.computed
-            ? [new LiteralValue(scope, key.name), []]
+            ? [new LiteralValue(key.name), []]
             : c.handleConsume(scope, prop.key);
         const propInit = init.get(scope, keyInst[0]);
         const declarationInst = Declare(c, scope, value, kind, propInit[0]);
@@ -966,14 +1002,14 @@ const DeclareObjectPattern = (c, scope, node, kind, base) => {
     return [null, [...inst, ...propertiesInst[1]]];
 };
 
-const Literal = (_c, scope, node) => [new LiteralValue(scope, node.value), []];
+const Literal = (_c, scope, node) => [new LiteralValue(node.value), []];
 const NumericLiteral = Literal;
 const StringLiteral = Literal;
-const NullLiteral = (_c, scope) => [
-    new LiteralValue(scope, null),
+const NullLiteral = () => [
+    new LiteralValue(null),
     [],
 ];
-const BooleanLiteral = (_c, scope, node) => [new LiteralValue(scope, +node.value), []];
+const BooleanLiteral = (_c, scope, node) => [new LiteralValue(+node.value), []];
 
 const LRExpression = (c, scope, node) => {
     const [left, leftInst] = c.handleConsume(scope, node.left);
@@ -985,35 +1021,26 @@ const BinaryExpression = LRExpression;
 const LogicalExpression = (c, scope, node) => {
     if (node.operator !== "??")
         return LRExpression(c, scope, node);
-    const nullLiteral = new LiteralValue(scope, null);
-    const endAdress = new LiteralValue(scope, null);
+    const other = lazyValue({
+        eval: scope => c.handleEval(scope, node.right),
+        consume: scope => c.handleConsume(scope, node.right),
+    });
     const [left, leftInst] = c.handleEval(scope, node.left);
-    const [nullTest] = left["=="](scope, nullLiteral);
-    if (nullTest instanceof LiteralValue) {
-        if (nullTest.data)
-            return c.handleEval(scope, node.right);
-        else
-            return [left, leftInst];
-    }
-    const [right, rightInst] = c.handleEval(scope, node.right);
-    const result = new StoreValue(scope);
-    result.ensureOwned();
-    return [
-        result,
-        [
-            ...leftInst,
-            ...result["="](scope, left)[1],
-            new JumpInstruction(endAdress, EJumpKind.NotEqual, result, nullLiteral),
-            ...rightInst,
-            ...result["="](scope, right)[1],
-            new AddressResolver(endAdress),
-        ],
-    ];
+    const [result, resultInst] = left["??"](scope, other);
+    return [result, [...leftInst, ...resultInst]];
 };
 const AssignmentExpression = (c, scope, node) => {
     const [left, leftInst] = c.handle(scope, node.left);
     // doesn't need to consume because the operators already do that
-    const [right, rightInst] = c.handleEval(scope, node.right);
+    const [right, rightInst] = node.operator !== "??="
+        ? c.handleEval(scope, node.right)
+        : [
+            lazyValue({
+                eval: scope => c.handleEval(scope, node.right),
+                consume: scope => c.handleConsume(scope, node.right),
+            }),
+            [],
+        ];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
     return [op, [...leftInst, ...rightInst, ...opInst]];
@@ -1045,13 +1072,13 @@ const ConditionalExpression = (c, scope, node) => {
     result.ensureOwned();
     const consequent = c.handleEval(scope, node.consequent);
     const alternate = c.handleEval(scope, node.alternate);
-    const alternateStartAdress = new LiteralValue(scope, null);
-    const endExpressionAdress = new LiteralValue(scope, null);
+    const alternateStartAdress = new LiteralValue(null);
+    const endExpressionAdress = new LiteralValue(null);
     return [
         result,
         [
             ...testInst,
-            new JumpInstruction(alternateStartAdress, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
+            new JumpInstruction(alternateStartAdress, EJumpKind.Equal, test, new LiteralValue(0)),
             ...consequent[1],
             ...result["="](scope, consequent[0])[1],
             new JumpInstruction(endExpressionAdress, EJumpKind.Always),
@@ -1061,7 +1088,13 @@ const ConditionalExpression = (c, scope, node) => {
             new AddressResolver(endExpressionAdress),
         ],
     ];
-};
+};
+function lazyValue(options) {
+    const value = new VoidValue();
+    value.eval = options.eval;
+    value.consume = options.consume;
+    return value;
+}
 
 const Identifier = (c, scope, node) => {
     return [scope.get(node.name), []];
@@ -1070,14 +1103,18 @@ const Identifier = (c, scope, node) => {
 const ExpressionStatement = (c, scope, node) => {
     return c.handle(scope, node.expression);
 };
-const BreakStatement = (_, scope) => {
-    const addr = new LiteralValue(scope, null);
-    scope.break.bind(addr);
+const BreakStatement = (_, scope, node) => {
+    const label = node.label?.name;
+    const target = label ? findScopeLabel(scope, label) : scope;
+    const addr = new LiteralValue(null);
+    target.break.bind(addr);
     return [null, [new BreakInstruction(addr)]];
 };
-const ContinueStatement = (_, scope) => {
-    const addr = new LiteralValue(scope, null);
-    scope.continue.bind(addr);
+const ContinueStatement = (_, scope, node) => {
+    const addr = new LiteralValue(null);
+    const label = node.label?.name;
+    const target = label ? findScopeLabel(scope, label) : scope;
+    target.continue.bind(addr);
     return [null, [new ContinueInstruction(addr)]];
 };
 const ReturnStatement = (c, scope, node) => {
@@ -1086,7 +1123,24 @@ const ReturnStatement = (c, scope, node) => {
         : [null, []];
     const [ret, retInst] = scope.function.return(scope, arg);
     return [ret, [...argInst, ...retInst]];
-};
+};
+const LabeledStatement = (c, scope, node) => {
+    const inner = scope.createScope();
+    inner.label = node.label.name;
+    const end = new LiteralValue(null);
+    const endAdress = new AddressResolver(end).bindBreak(inner);
+    const [, bodyInst] = c.handle(inner, node.body);
+    return [null, [...bodyInst, endAdress]];
+};
+function findScopeLabel(scope, label) {
+    let current = scope;
+    while (current !== null) {
+        if (current.label === label)
+            return current;
+        current = current.parent;
+    }
+    throw new CompilerError(`Could not find label "${label}"`);
+}
 
 const IfStatement = (c, scope, node) => {
     const inst = [];
@@ -1098,9 +1152,9 @@ const IfStatement = (c, scope, node) => {
             inst.push(...c.handle(scope, node.alternate)[1]);
         return [null, inst];
     }
-    const endIfAddr = new LiteralValue(scope, null);
-    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1], new AddressResolver(endIfAddr));
-    const endElseAddr = new LiteralValue(scope, null);
+    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(new JumpInstruction(endElseAddr, EJumpKind.Always), new AddressResolver(endIfAddr), ...withAlwaysRuns(c.handle(scope, node.alternate), false)[1], new AddressResolver(endElseAddr));
     }
@@ -1111,13 +1165,13 @@ const SwitchStatement = (c, scope, node) => {
     const innerScope = scope.createScope();
     const [ref, refInst] = c.handleConsume(scope, node.discriminant);
     const inst = [];
-    const endAdress = new LiteralValue(innerScope, null);
+    const endAdress = new LiteralValue(null);
     const endLine = new AddressResolver(endAdress).bindBreak(innerScope);
     const caseJumps = [];
     let defaultJump;
     for (const scase of node.cases) {
         const [, bodyInst] = c.handleMany(innerScope, scase.consequent);
-        const bodyAdress = new LiteralValue(innerScope, null);
+        const bodyAdress = new LiteralValue(null);
         const bodyLine = new AddressResolver(bodyAdress);
         if (!scase.test) {
             [defaultJump] = c.handle(innerScope, scase, () => [
@@ -1171,25 +1225,33 @@ const SwitchStatement = (c, scope, node) => {
 const WhileStatement = (c, scope, node) => {
     const lines = [];
     const [test, testLines] = c.handleConsume(scope, node.test);
-    const startLoopAddr = new LiteralValue(scope, null);
-    const endLoopAddr = new LiteralValue(scope, null);
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
-    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    const childScope = scope.createScope();
+    const startLoopAddr = new LiteralValue(null);
+    const endLoopAddr = new LiteralValue(null);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
+    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(childScope);
+    if (scope.label) {
+        startLoopLine.bindContinue(scope);
+    }
     if (test instanceof LiteralValue) {
         if (test.data) {
-            lines.push(startLoopLine, ...c.handle(scope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+            lines.push(startLoopLine, ...c.handle(childScope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
         }
         return [null, lines];
     }
-    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...withAlwaysRuns(c.handle(scope, node.body), false)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(childScope, node.body), false)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
     return [null, lines];
 };
 const DoWhileStatement = (c, scope, node) => {
     const lines = [];
     const [test, testLines] = c.handleConsume(scope, node.test);
-    const startLoopAddr = new LiteralValue(scope, null);
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
-    const [, bodyLines] = c.handle(scope, node.body);
+    const childScope = scope.createScope();
+    const startLoopAddr = new LiteralValue(null);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
+    if (scope.label) {
+        startLoopLine.bindContinue(scope);
+    }
+    const [, bodyLines] = c.handle(childScope, node.body);
     if (test instanceof LiteralValue) {
         if (!test.data)
             return [null, [...lines, ...bodyLines]];
@@ -1203,28 +1265,31 @@ const DoWhileStatement = (c, scope, node) => {
             ],
         ];
     }
-    lines.push(startLoopLine, ...bodyLines, ...testLines, new JumpInstruction(startLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 1)));
+    lines.push(startLoopLine, ...bodyLines, ...testLines, new JumpInstruction(startLoopAddr, EJumpKind.Equal, test, new LiteralValue(1)));
     return [null, lines];
 };
 
-const ForStatement = (c, scope, node) => {
-    scope = scope.createScope();
+const ForStatement = (c, parentScope, node) => {
+    const scope = parentScope.createScope();
     const initInst = node.init ? c.handle(scope, node.init)[1] : [];
     const [test, testLines] = node.test
         ? c.handleConsume(scope, node.test)
-        : [new LiteralValue(scope, 1), []];
+        : [new LiteralValue(1), []];
     const updateLines = node.update ? c.handle(scope, node.update)[1] : [];
-    const startLoopAddr = new LiteralValue(scope, null);
-    const endLoopAddr = new LiteralValue(scope, null);
+    const startLoopAddr = new LiteralValue(null);
+    const endLoopAddr = new LiteralValue(null);
     const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
     const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    if (parentScope.label) {
+        startLoopLine.bindContinue(parentScope);
+    }
     return [
         null,
         [
             ...initInst,
             startLoopLine,
             ...testLines,
-            new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
+            new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(0)),
             ...withAlwaysRuns(c.handle(scope, node.body), false)[1],
             ...updateLines,
             new JumpInstruction(startLoopAddr, EJumpKind.Always),
@@ -1234,20 +1299,20 @@ const ForStatement = (c, scope, node) => {
 };
 
 class FunctionValue extends VoidValue {
-    constructor({ scope, params, body, c, node, }) {
-        super(scope);
+    constructor({ scope, params, body, c, }) {
+        super();
         this.mutability = EMutability.constant;
         this.macro = true;
         this.paramOwners = [];
         this.bundled = false;
         this.initialized = false;
+        this.scope = scope;
         this.body = body;
         this.c = c;
-        this.node = node;
         this.params = params;
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "function"), []];
+    typeof() {
+        return [new LiteralValue("function"), []];
     }
     initScope(name) {
         this.childScope = this.scope.createFunction(name);
@@ -1275,7 +1340,7 @@ class FunctionValue extends VoidValue {
         this.initialized = true;
         const { name } = this.owner;
         this.initScope(name);
-        this.addr = new LiteralValue(this.childScope, null);
+        this.addr = new LiteralValue(null);
         this.temp = new ValueOwner({
             scope: this.childScope,
             name: `${internalPrefix}f${name}`,
@@ -1309,7 +1374,7 @@ class FunctionValue extends VoidValue {
         if (!this.bundled)
             this.childScope.inst.push(...this.inst);
         this.bundled = true;
-        const callAddressLiteral = new LiteralValue(scope, null);
+        const callAddressLiteral = new LiteralValue(null);
         const inst = this.paramOwners
             .map(({ value: param }, i) => param["="](scope, args[i])[1])
             .reduce((s, c) => s.concat(c), [])
@@ -1347,7 +1412,7 @@ class FunctionValue extends VoidValue {
                 name: owner.name,
             }));
         });
-        this.inlineEnd = new LiteralValue(scope, null);
+        this.inlineEnd = new LiteralValue(null);
         this.tryingInline = true;
         let inst = this.c.handle(fnScope, this.body)[1];
         this.tryingInline = false;
@@ -1406,7 +1471,6 @@ function handleFunctionNode(c, scope, node) {
     }
     return [
         new FunctionValue({
-            node,
             scope,
             params: params,
             body,
@@ -1452,8 +1516,8 @@ const NewExpression = CallExpression;
 const TaggedTemplateExpression = (c, scope, node) => {
     const [tag, tagInst] = c.handleConsume(scope, node.tag);
     const template = node.quasi;
-    const stringsObject = ObjectValue.fromArray(scope, template.quasis.map(quasi => new LiteralValue(scope, quasi.value.cooked ?? "")), {
-        raw: ObjectValue.fromArray(scope, template.quasis.map(quasi => new LiteralValue(scope, quasi.value.raw))),
+    const stringsObject = ObjectValue.fromArray(template.quasis.map(quasi => new LiteralValue(quasi.value.cooked ?? "")), {
+        raw: ObjectValue.fromArray(template.quasis.map(quasi => new LiteralValue(quasi.value.raw))),
     });
     const expressions = [];
     const expressionInsts = [];
@@ -1498,7 +1562,7 @@ const ObjectExpression = (c, scope, node) => {
         data[index] = member;
         inst.push(...memberInst);
     }
-    return [new ObjectValue(scope, data), inst];
+    return [new ObjectValue(data), inst];
 };
 const ArrayExpression = (c, scope, node) => {
     const items = [];
@@ -1510,13 +1574,13 @@ const ArrayExpression = (c, scope, node) => {
         items.push(value);
         inst.push(...valueInst);
     });
-    return [ObjectValue.fromArray(scope, items), inst];
+    return [ObjectValue.fromArray(items), inst];
 };
 const MemberExpression = (c, scope, node) => {
     const [obj, objInst] = c.handleConsume(scope, node.object);
     const [prop, propInst] = node.computed
         ? c.handleConsume(scope, node.property)
-        : [new LiteralValue(scope, node.property.name), []];
+        : [new LiteralValue(node.property.name), []];
     const [got, gotInst] = obj.get(scope, prop);
     return [got, [...objInst, ...propInst, ...gotInst]];
 };
@@ -1531,9 +1595,9 @@ const ArrayPattern = (c, scope, node) => {
         if (!valueInst[0])
             throw new CompilerError("Destructuring element must resolve to a value", element);
         inst.push(...valueInst[1]);
-        members.set(new LiteralValue(scope, i), valueInst[0]);
+        members.set(new LiteralValue(i), valueInst[0]);
     }
-    return [new DestructuringValue(scope, members), inst];
+    return [new DestructuringValue(members), inst];
 };
 const ObjectPattern = (c, scope, node) => {
     const inst = [];
@@ -1545,7 +1609,7 @@ const ObjectPattern = (c, scope, node) => {
             continue;
         const { key } = prop;
         const keyInst = !prop.computed && key.type === "Identifier"
-            ? [new LiteralValue(scope, key.name), []]
+            ? [new LiteralValue(key.name), []]
             : c.handleConsume(scope, prop.key);
         inst.push(...keyInst[1]);
         const valueInst = c.handle(scope, prop.value);
@@ -1554,7 +1618,7 @@ const ObjectPattern = (c, scope, node) => {
         inst.push(...valueInst[1]);
         members.set(keyInst[0], valueInst[0]);
     }
-    return [new DestructuringValue(scope, members), inst];
+    return [new DestructuringValue(members), inst];
 };
 
 const TemplateLiteral = () => {
@@ -1594,7 +1658,7 @@ const TSEnumDeclaration = (c, scope, node) => {
             throw new CompilerError("This enum member must be initialized", member);
         const [value] = member.initializer
             ? c.handleEval(scope, member.initializer)
-            : [new LiteralValue(scope, counter)];
+            : [new LiteralValue(counter)];
         if (!(value instanceof LiteralValue))
             throw new CompilerError("Enum members must contain literal values", member);
         if (typeof value.data === "number") {
@@ -1609,7 +1673,7 @@ const TSEnumDeclaration = (c, scope, node) => {
     }
     scope.set(new ValueOwner({
         scope,
-        value: new ObjectValue(scope, data),
+        value: new ObjectValue(data),
         constant: true,
         identifier: node.id.name,
         name: nodeName(node, !c.compactNames && node.id.name),
@@ -1641,6 +1705,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     BreakStatement: BreakStatement,
     ContinueStatement: ContinueStatement,
     ReturnStatement: ReturnStatement,
+    LabeledStatement: LabeledStatement,
     IfStatement: IfStatement,
     SwitchStatement: SwitchStatement,
     WhileStatement: WhileStatement,
@@ -1670,14 +1735,14 @@ var handlers = /*#__PURE__*/Object.freeze({
 });
 
 class MacroFunction extends VoidValue {
-    constructor(scope, fn) {
-        super(scope);
+    constructor(fn) {
+        super();
         this.macro = true;
-        this.constant = true;
+        this.mutability = EMutability.constant;
         this.fn = fn;
     }
     call(scope, args) {
-        return this.fn.apply(this, args);
+        return this.fn.apply(this, [scope, ...args]);
     }
     eval(_scope) {
         return [this, []];
@@ -1708,16 +1773,31 @@ const mathOperations = {
     sqrt: a => Math.sqrt(a),
     rand: null,
 };
+function mathConstant(scope, name) {
+    return new ValueOwner({
+        scope,
+        constant: true,
+        name,
+        value: assign(new StoreValue(scope), {
+            mutability: EMutability.constant,
+        }),
+    }).value;
+}
 function createMacroMathOperations(scope) {
-    const macroMathOperations = {};
+    const macroMathOperations = {
+        PI: mathConstant(scope, "@pi"),
+        E: mathConstant(scope, "@e"),
+        degToRad: mathConstant(scope, "@degToRad"),
+        radToDeg: mathConstant(scope, "@radToDeg"),
+    };
     for (const key in mathOperations) {
         const fn = mathOperations[key];
-        macroMathOperations[key] = new MacroFunction(scope, (a, b) => {
+        macroMathOperations[key] = new MacroFunction((scope, a, b) => {
             if (b) {
                 if (fn && a instanceof LiteralValue && b instanceof LiteralValue) {
                     if (typeof a.data !== "number" || typeof b.data !== "number")
                         throw new CompilerError("Cannot do math operation with non-numerical literals.");
-                    return [new LiteralValue(scope, fn(a.num, b.num)), []];
+                    return [new LiteralValue(fn(a.num, b.num)), []];
                 }
                 const temp = new StoreValue(scope);
                 return [temp, [new OperationInstruction(key, temp, a, b)]];
@@ -1725,7 +1805,7 @@ function createMacroMathOperations(scope) {
             if (fn && a instanceof LiteralValue) {
                 if (typeof a.data !== "number")
                     throw new CompilerError("Cannot do math operation with non-numerical literal.");
-                return [new LiteralValue(scope, fn(a.num)), []];
+                return [new LiteralValue(fn(a.num)), []];
             }
             const temp = new StoreValue(scope);
             return [temp, [new OperationInstruction(key, temp, a, b)]];
@@ -1735,20 +1815,20 @@ function createMacroMathOperations(scope) {
 }
 class MlogMath extends ObjectValue {
     constructor(scope) {
-        super(scope, createMacroMathOperations(scope));
+        super(createMacroMathOperations(scope));
     }
 }
 // op angle result a b
 // op len result a b
 
 class Concat extends MacroFunction {
-    constructor(scope) {
-        super(scope, (...values) => {
+    constructor() {
+        super((scope, ...values) => {
             for (const value of values)
                 if (!(value instanceof LiteralValue))
                     throw new CompilerError("Concat arguments must all be literal values.");
             return [
-                new LiteralValue(scope, values.map(v => v.data).join("")),
+                new LiteralValue(values.map(v => v.data).join("")),
                 [],
             ];
         });
@@ -1803,18 +1883,18 @@ function assertObjectFields(value, fields) {
 }
 
 /** Used to create namespaces that contain multiple methods that map into instructions */
-function createOverloadNamespace({ scope, overloads, handler, }) {
+function createOverloadNamespace({ overloads, handler, }) {
     const result = {};
     for (const key in overloads) {
         const { named, args } = overloads[key];
         if (named) {
-            result[key] = new MacroFunction(scope, options => {
+            result[key] = new MacroFunction((scope, options) => {
                 assertIsObjectMacro(options, named);
-                return handler(key, ...assertObjectFields(options, args));
+                return handler(scope, key, ...assertObjectFields(options, args));
             });
             continue;
         }
-        result[key] = new MacroFunction(scope, (...params) => {
+        result[key] = new MacroFunction((scope, ...params) => {
             const handlerParams = [];
             // validate the paramters
             for (let i = 0; i < args.length; i++) {
@@ -1831,16 +1911,15 @@ function createOverloadNamespace({ scope, overloads, handler, }) {
                 arg.validate?.(param);
                 handlerParams.push(param);
             }
-            return handler(key, ...handlerParams);
+            return handler(scope, key, ...handlerParams);
         });
     }
     return result;
 }
 
 class Draw extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 clear: {
                     args: ["r", "g", "b"],
@@ -1877,17 +1956,17 @@ class Draw extends ObjectValue {
                     args: ["x", "y", "image", "size", "rotation"],
                 },
             },
-            handler(overload, ...args) {
+            handler(scope, overload, ...args) {
                 return [null, [new InstructionBase("draw", overload, ...args)]];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class Print extends MacroFunction {
-    constructor(scope) {
-        super(scope, (...values) => {
+    constructor() {
+        super((scope, ...values) => {
             const [first] = values;
             const inst = [];
             if (!isTemplateObjectArray(first)) {
@@ -1900,12 +1979,12 @@ class Print extends MacroFunction {
             // maybe this should be checked in another way?
             const { length } = first.data;
             for (let i = 1; i < values.length; i++) {
-                const [string] = first.get(scope, new LiteralValue(scope, i - 1));
+                const [string] = first.get(scope, new LiteralValue(i - 1));
                 if (string.data)
                     inst.push(new InstructionBase("print", string));
                 inst.push(new InstructionBase("print", values[i]));
             }
-            const [tail] = first.get(scope, new LiteralValue(scope, length.data - 1));
+            const [tail] = first.get(scope, new LiteralValue(length.data - 1));
             if (tail.data)
                 inst.push(new InstructionBase("print", tail));
             return [null, inst];
@@ -1915,8 +1994,8 @@ class Print extends MacroFunction {
 
 const defaultTargetName$1 = "message1";
 class PrintFlush extends MacroFunction {
-    constructor(scope) {
-        super(scope, (target) => {
+    constructor() {
+        super((scope, target) => {
             if (!target)
                 return [null, [new InstructionBase("printflush", defaultTargetName$1)]];
             if (!(target instanceof SenseableValue))
@@ -1928,8 +2007,8 @@ class PrintFlush extends MacroFunction {
 
 const defaultTargetName = "display1";
 class DrawFlush extends MacroFunction {
-    constructor(scope) {
-        super(scope, (target) => {
+    constructor() {
+        super((scope, target) => {
             if (!target)
                 return [null, [new InstructionBase("drawflush", defaultTargetName)]];
             if (!(target instanceof SenseableValue))
@@ -1940,16 +2019,15 @@ class DrawFlush extends MacroFunction {
 }
 
 class GetBlock extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 floor: { args: ["x", "y"] },
                 ore: { args: ["x", "y"] },
                 block: { args: ["x", "y"] },
                 building: { args: ["x", "y"] },
             },
-            handler(overload, x, y) {
+            handler(scope, overload, x, y) {
                 const output = overload === "building"
                     ? new SenseableValue(scope)
                     : new StoreValue(scope);
@@ -1959,13 +2037,13 @@ class GetBlock extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class GetLink extends MacroFunction {
-    constructor(scope) {
-        super(scope, (index) => {
+    constructor() {
+        super((scope, index) => {
             if (!(index instanceof StoreValue) &&
                 (!(index instanceof LiteralValue) || typeof index.data !== "number"))
                 throw new CompilerError("The getlink index must be a number literal or a store");
@@ -1976,9 +2054,8 @@ class GetLink extends MacroFunction {
 }
 
 class Control extends ObjectValue {
-    constructor(scope) {
-        super(scope, createOverloadNamespace({
-            scope,
+    constructor() {
+        super(createOverloadNamespace({
             overloads: {
                 enabled: { args: ["building", "value"] },
                 shoot: {
@@ -1992,7 +2069,7 @@ class Control extends ObjectValue {
                 config: { args: ["building", "value"] },
                 color: { args: ["building", "r", "g", "b"] },
             },
-            handler(overload, ...args) {
+            handler(scope, overload, ...args) {
                 return [null, [new InstructionBase("control", overload, ...args)]];
             },
         }));
@@ -2017,8 +2094,8 @@ const validRadarSorts = [
     "maxHealth",
 ];
 class Radar extends MacroFunction {
-    constructor(scope) {
-        super(scope, options => {
+    constructor() {
+        super((scope, options) => {
             assertIsObjectMacro(options, "The radar options");
             const { building, filters, order, sort } = options.data;
             if (!(building instanceof SenseableValue))
@@ -2049,8 +2126,8 @@ class Radar extends MacroFunction {
 }
 
 class Sensor extends MacroFunction {
-    constructor(scope) {
-        super(scope, (property, target) => {
+    constructor() {
+        super((scope, property, target) => {
             if (!(property instanceof StoreValue))
                 throw new CompilerError("The sensor property must be a store");
             if (!(target instanceof SenseableValue))
@@ -2064,8 +2141,8 @@ class Sensor extends MacroFunction {
 }
 
 class Wait extends MacroFunction {
-    constructor(scope) {
-        super(scope, seconds => {
+    constructor() {
+        super((scope, seconds) => {
             if (!(seconds instanceof StoreValue) &&
                 !(seconds instanceof LiteralValue && typeof seconds.data === "number"))
                 throw new CompilerError("The wait seconds must be either a number literal or a store");
@@ -2075,16 +2152,15 @@ class Wait extends MacroFunction {
 }
 
 class Lookup extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 block: { args: ["index"] },
                 unit: { args: ["index"] },
                 item: { args: ["index"] },
                 liquid: { args: ["index"] },
             },
-            handler(overload, index) {
+            handler(scope, overload, index) {
                 const output = new StoreValue(scope);
                 return [
                     output,
@@ -2092,13 +2168,13 @@ class Lookup extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class PackColor extends MacroFunction {
-    constructor(scope) {
-        super(scope, (...args) => {
+    constructor() {
+        super((scope, ...args) => {
             if (args.length !== 4) {
                 throw new CompilerError(`Expected 4 arguments, received ${args.length}`);
             }
@@ -2113,15 +2189,14 @@ class PackColor extends MacroFunction {
 }
 
 class End extends MacroFunction {
-    constructor(scope) {
-        super(scope, () => [null, [new EndInstruction()]]);
+    constructor() {
+        super(() => [null, [new EndInstruction()]]);
     }
 }
 
 class SetBlock extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 floor: { args: ["x", "y", "to"] },
                 ore: { args: ["x", "y", "to"] },
@@ -2130,7 +2205,7 @@ class SetBlock extends ObjectValue {
                     args: ["x", "y", "to", "team", { key: "rotation", default: "0" }],
                 },
             },
-            handler(overload, x, y, to, team, rotation) {
+            handler(scope, overload, x, y, to, team, rotation) {
                 return [
                     null,
                     [
@@ -2139,13 +2214,13 @@ class SetBlock extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class SpawnUnit extends MacroFunction {
-    constructor(scope) {
-        super(scope, options => {
+    constructor() {
+        super((scope, options) => {
             assertIsObjectMacro(options, "The options");
             const { type, x, y, team, rotation } = options.data;
             assertIsRuntimeValue(type, "type");
@@ -2164,14 +2239,14 @@ class SpawnUnit extends MacroFunction {
 }
 
 class Stop extends MacroFunction {
-    constructor(scope) {
-        super(scope, () => [null, [new InstructionBase("stop")]]);
+    constructor() {
+        super(() => [null, [new InstructionBase("stop")]]);
     }
 }
 
 class UnitBind extends MacroFunction {
-    constructor(scope) {
-        super(scope, type => {
+    constructor() {
+        super((scope, type) => {
             if (!(type instanceof StoreValue))
                 throw new CompilerError("The unitBind type must be a store");
             return [null, [new InstructionBase("ubind", type)]];
@@ -2180,9 +2255,8 @@ class UnitBind extends MacroFunction {
 }
 
 class UnitControl extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 idle: { args: [] },
                 stop: { args: [] },
@@ -2211,21 +2285,21 @@ class UnitControl extends ObjectValue {
                     args: ["x", "y", "radius"],
                 },
             },
-            handler(overload, ...args) {
+            handler(scope, overload, ...args) {
                 let result = null;
                 let extraArgs = [];
                 switch (overload) {
                     case "getBlock": {
                         const outType = new StoreValue(scope);
                         const outBuilding = new SenseableValue(scope);
-                        result = ObjectValue.fromArray(scope, [outType, outBuilding]);
-                        extraArgs = [outType, outBuilding, new LiteralValue(scope, 0)];
+                        result = ObjectValue.fromArray([outType, outBuilding]);
+                        extraArgs = [outType, outBuilding, new LiteralValue(0)];
                         break;
                     }
                     case "within": {
                         const temp = new StoreValue(scope);
                         result = temp;
-                        extraArgs = [temp, new LiteralValue(scope, 0)];
+                        extraArgs = [temp, new LiteralValue(0)];
                         break;
                     }
                 }
@@ -2235,13 +2309,13 @@ class UnitControl extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class UnitRadar extends MacroFunction {
-    constructor(scope) {
-        super(scope, options => {
+    constructor() {
+        super((scope, options) => {
             assertIsObjectMacro(options, "The radar options");
             const { filters, order, sort } = options.data;
             assertIsArrayMacro(filters, "filters");
@@ -2282,9 +2356,8 @@ const validBuildingGroups = [
     "reactor",
 ];
 class UnitLocate extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 ore: {
                     args: ["ore"],
@@ -2297,7 +2370,7 @@ class UnitLocate extends ObjectValue {
                     args: [],
                 },
             },
-            handler(overload, ...args) {
+            handler(scope, overload, ...args) {
                 const outFound = new StoreValue(scope);
                 const outX = new StoreValue(scope);
                 const outY = new StoreValue(scope);
@@ -2325,7 +2398,7 @@ class UnitLocate extends ObjectValue {
                     }
                 }
                 return [
-                    ObjectValue.fromArray(scope, [
+                    ObjectValue.fromArray([
                         outFound,
                         outX,
                         outY,
@@ -2335,7 +2408,7 @@ class UnitLocate extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
@@ -2356,16 +2429,15 @@ const validEffects = [
     "blasted",
 ];
 class ApplyStatus extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 apply: {
                     args: ["status", "unit", { key: "duration", default: "10" }],
                 },
                 clear: { args: ["status", "unit"] },
             },
-            handler(overload, effect, unit, duration) {
+            handler(scope, overload, effect, unit, duration) {
                 if (!(effect instanceof LiteralValue))
                     throw new CompilerError("The status effect must be a string literal");
                 assertLiteralOneOf(effect, validEffects, "The status effect");
@@ -2377,13 +2449,13 @@ class ApplyStatus extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class SpawnWave extends MacroFunction {
-    constructor(scope) {
-        super(scope, (natural, x, y) => {
+    constructor() {
+        super((scope, natural, x, y) => {
             if (!(natural instanceof LiteralValue) ||
                 (natural.data !== 1 && natural.data !== 0))
                 throw new CompilerError("The 'natural' argument must be a boolean literal");
@@ -2398,9 +2470,8 @@ class SpawnWave extends MacroFunction {
 }
 
 class SetRule extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 currentWaveTime: { args: ["seconds"] },
                 waveTimer: { args: ["enabled"] },
@@ -2418,13 +2489,14 @@ class SetRule extends ObjectValue {
                 solarMultiplier: { args: ["multiplier"] },
                 buildSpeed: { args: ["team", "multiplier"] },
                 unitBuildSpeed: { args: ["team", "multiplier"] },
+                unitCost: { args: ["team", "multiplier"] },
                 unitDamage: { args: ["team", "multiplier"] },
                 blockHealth: { args: ["team", "multiplier"] },
                 blockDamage: { args: ["team", "multiplier"] },
                 rtsMinWeight: { args: ["team", "value"] },
                 rtsMinSquad: { args: ["team", "value"] },
             },
-            handler(overload, ...args) {
+            handler(scope, overload, ...args) {
                 const params = ["10", "0", "0", "100", "100"];
                 switch (overload) {
                     case "mapArea": {
@@ -2437,6 +2509,7 @@ class SetRule extends ObjectValue {
                     }
                     case "buildSpeed":
                     case "unitBuildSpeed":
+                    case "unitCost":
                     case "unitDamage":
                     case "blockHealth":
                     case "blockDamage":
@@ -2444,7 +2517,7 @@ class SetRule extends ObjectValue {
                     case "rtsMinSquad": {
                         const [team, value] = args;
                         params[1] = team;
-                        params[2] = value;
+                        params[0] = value;
                         break;
                     }
                     default:
@@ -2453,49 +2526,47 @@ class SetRule extends ObjectValue {
                 return [null, [new InstructionBase("setrule", overload, ...params)]];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class FlushMessage extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 notify: { args: [] },
                 mission: { args: [] },
                 announce: { args: ["duration"] },
                 toast: { args: ["duration"] },
             },
-            handler(overload, duration) {
+            handler(scope, overload, duration) {
                 return [null, [new InstructionBase("message", overload, duration)]];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class Cutscene extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 pan: { named: "options", args: ["x", "y", "speed"] },
                 zoom: { args: ["level"] },
                 stop: { args: [] },
             },
-            handler(overload, ...args) {
+            handler(scope, overload, ...args) {
                 const params = Object.assign(["100", "100", "0.06", "0"], args);
                 return [null, [new InstructionBase("cutscene", overload, ...params)]];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class Explosion extends MacroFunction {
-    constructor(scope) {
-        super(scope, options => {
+    constructor() {
+        super((scope, options) => {
             assertIsObjectMacro(options, "The options");
             const params = assertObjectFields(options, [
                 "team",
@@ -2513,15 +2584,14 @@ class Explosion extends MacroFunction {
 }
 
 class SetRate extends MacroFunction {
-    constructor(scope) {
-        super(scope, ipt => [null, [new InstructionBase("setrate", ipt)]]);
+    constructor() {
+        super((scope, ipt) => [null, [new InstructionBase("setrate", ipt)]]);
     }
 }
 
 class Fetch extends ObjectValue {
-    constructor(scope) {
+    constructor() {
         const data = createOverloadNamespace({
-            scope,
             overloads: {
                 unit: { args: ["team", "index"] },
                 unitCount: { args: ["team"] },
@@ -2532,7 +2602,7 @@ class Fetch extends ObjectValue {
                 build: { args: ["team", "index", "block"] },
                 buildCount: { args: ["team", "block"] },
             },
-            handler(overload, team, ...rest) {
+            handler(scope, overload, team, ...rest) {
                 const output = new SenseableValue(scope);
                 const params = ["0", "@conveyor"];
                 if (overload === "buildCount") {
@@ -2547,13 +2617,13 @@ class Fetch extends ObjectValue {
                 ];
             },
         });
-        super(scope, data);
+        super(data);
     }
 }
 
 class GetFlag extends MacroFunction {
-    constructor(scope) {
-        super(scope, flag => {
+    constructor() {
+        super((scope, flag) => {
             const result = new StoreValue(scope);
             return [result, [new InstructionBase("getflag", result, flag)]];
         });
@@ -2561,8 +2631,8 @@ class GetFlag extends MacroFunction {
 }
 
 class SetFlag extends MacroFunction {
-    constructor(scope) {
-        super(scope, (flag, value) => {
+    constructor() {
+        super((scope, flag, value) => {
             if (!flag)
                 throw new CompilerError("Missing flag argument");
             if (!value)
@@ -2572,36 +2642,48 @@ class SetFlag extends MacroFunction {
     }
 }
 
-class MemoryEntry extends ObjectValue {
+class MemoryEntry extends BaseValue {
     constructor(scope, mem, prop) {
-        super(scope, {
-            $eval: new MacroFunction(scope, () => {
-                if (this.store)
-                    return [this.store, []];
-                const temp = new StoreValue(scope);
-                return [temp, [new InstructionBase("read", temp, mem.cell, prop)]];
-            }),
-            $consume: new MacroFunction(scope, () => {
-                if (this.store)
-                    return [this.store, []];
-                this.ensureOwned();
-                this.store = new StoreValue(scope);
-                this.owner.own(this.store);
-                return [
-                    this.store,
-                    [new InstructionBase("read", this.store, mem.cell, prop)],
-                ];
-            }),
-            "$=": new MacroFunction(scope, value => {
-                const [data, dataInst] = value.consume(scope);
-                return [
-                    data,
-                    [...dataInst, new InstructionBase("write", data, mem.cell, prop)],
-                ];
-            }),
-        });
+        super();
+        this.scope = scope;
+        this.mem = mem;
+        this.prop = prop;
+        this.macro = true;
         this.store = null;
     }
+    eval(scope) {
+        if (this.store)
+            return [this.store, []];
+        const temp = new StoreValue(scope);
+        return [
+            temp,
+            [new InstructionBase("read", temp, this.mem.cell, this.prop)],
+        ];
+    }
+    consume(scope) {
+        if (this.store)
+            return [this.store, []];
+        this.ensureOwned();
+        this.store = new StoreValue(scope);
+        this.owner.own(this.store);
+        return [
+            this.store,
+            [new InstructionBase("read", this.store, this.mem.cell, this.prop)],
+        ];
+    }
+    "="(scope, value) {
+        const [data, dataInst] = value.consume(scope);
+        return [
+            data,
+            [
+                ...dataInst,
+                new InstructionBase("write", data, this.mem.cell, this.prop),
+            ],
+        ];
+    }
+    ensureOwned() {
+        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    }
 }
 for (const operator of operators) {
     if (operator === "=")
@@ -2612,9 +2694,9 @@ for (const operator of operators) {
     };
 }
 class MemoryMacro extends ObjectValue {
-    constructor(scope, cell, size) {
-        super(scope, {
-            $get: new MacroFunction(scope, (prop) => {
+    constructor(cell, size) {
+        super({
+            $get: new MacroFunction((scope, prop) => {
                 if (prop instanceof LiteralValue && typeof prop.data !== "number")
                     throw new CompilerError(`Invalid memory object property: "${prop.data}"`);
                 const obj = new MemoryEntry(scope, this, prop);
@@ -2624,21 +2706,20 @@ class MemoryMacro extends ObjectValue {
             size,
         });
         this.cell = cell;
-        this.name = cell.toString();
     }
     toString() {
-        return this.name;
+        return this.cell.toString();
     }
 }
 class MemoryBuilder extends ObjectValue {
-    constructor(scope) {
-        super(scope, {
-            $call: new MacroFunction(scope, (cell, size = new LiteralValue(scope, 64)) => {
+    constructor() {
+        super({
+            $call: new MacroFunction((scope, cell, size = new LiteralValue(64)) => {
                 if (!(cell instanceof SenseableValue))
                     throw new CompilerError("Memory cell must be a senseable value.");
                 if (!(size instanceof LiteralValue && typeof size.data === "number"))
                     throw new CompilerError("The memory size must be a number literal.");
-                return [new MemoryMacro(scope, cell, size), []];
+                return [new MemoryMacro(cell, size), []];
             }),
         });
     }
@@ -2646,9 +2727,9 @@ class MemoryBuilder extends ObjectValue {
 
 const dynamicVars = ["time", "tick"];
 class NamespaceMacro extends ObjectValue {
-    constructor(scope, { changeCasing = false } = {}) {
-        super(scope, {
-            $get: new MacroFunction(scope, prop => {
+    constructor({ changeCasing = false } = {}) {
+        super({
+            $get: new MacroFunction((scope, prop) => {
                 if (!(prop instanceof LiteralValue) || typeof prop.data !== "string")
                     throw new CompilerError("Cannot use dynamic properties on namespace macros");
                 const symbolName = this.changeCasing
@@ -2672,7 +2753,7 @@ class NamespaceMacro extends ObjectValue {
 }
 class VarsNamespace extends NamespaceMacro {
     constructor(scope) {
-        super(scope);
+        super();
         Object.assign(this.data, {
             unit: new ValueOwner({
                 scope,
@@ -2689,8 +2770,8 @@ class VarsNamespace extends NamespaceMacro {
 }
 
 class GetGlobal extends MacroFunction {
-    constructor(scope, mutability) {
-        super(scope, (name) => {
+    constructor(mutability) {
+        super((scope, name) => {
             if (!(name instanceof LiteralValue) || typeof name.data !== "string")
                 throw new CompilerError("The name parameter must be a string literal.");
             const owner = new ValueOwner({
@@ -2706,22 +2787,77 @@ class GetGlobal extends MacroFunction {
 }
 
 class Asm extends MacroFunction {
-    constructor(scope) {
-        super(scope, (stringsArray, ...values) => {
+    constructor() {
+        super((scope, stringsArray, ...values) => {
             if (!isTemplateObjectArray(stringsArray))
                 throw new CompilerError("Expected to receive a template strings array");
             const args = [];
             for (let i = 0; i < values.length; i++) {
-                const [item] = stringsArray.get(scope, new LiteralValue(scope, i));
+                const [item] = stringsArray.get(scope, new LiteralValue(i));
                 args.push(item.data);
                 args.push(values[i]);
             }
             const { length } = stringsArray.data;
-            const [tail] = stringsArray.get(scope, new LiteralValue(scope, length.data - 1));
+            const [tail] = stringsArray.get(scope, new LiteralValue(length.data - 1));
             args.push(tail.data);
-            return [null, [new ZeroSpaceInstruction(...args)]];
+            return [null, formatInstructions(args)];
         });
     }
+}
+/** Splits multiline asm calls and formats each line. */
+function formatInstructions(args) {
+    const instructions = [];
+    let buffer = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg !== "string" || !arg.includes("\n")) {
+            buffer.push(arg);
+            continue;
+        }
+        const segments = arg.split("\n");
+        const params = [...buffer, segments[0]];
+        if (validateInstructionArgs(params)) {
+            instructions.push(new ZeroSpaceInstruction(...params));
+            buffer = [];
+        }
+        // iterates over all segments except the first and last
+        // the first segment was already processed above
+        // the last segment will be added to the buffer because there might
+        // be an interpolation after it
+        // and putting it in the buffer makes sure it has a proper output format
+        for (let i = 1; i < segments.length - 1; i++) {
+            const trimmed = segments[i].trim();
+            if (trimmed.length == 0)
+                continue;
+            instructions.push(new ZeroSpaceInstruction(trimmed));
+        }
+        if (segments.length > 1) {
+            buffer.push(segments[segments.length - 1]);
+        }
+    }
+    if (buffer.length > 0 && validateInstructionArgs(buffer)) {
+        instructions.push(new ZeroSpaceInstruction(...buffer));
+    }
+    return instructions;
+}
+/** Determines if an asm line should be generated and trims it at the start and end */
+function validateInstructionArgs(args) {
+    if (args.length === 0)
+        return false;
+    if (args.length === 1) {
+        const item = args[0];
+        if (typeof item !== "string")
+            return true;
+        args[0] = item.trim();
+        return args[0].length !== 0;
+    }
+    const first = args[0];
+    const last = args[args.length - 1];
+    if (typeof first === "string")
+        args[0] = first.trimStart();
+    if (typeof last === "string")
+        args[args.length - 1] = last.trimEnd();
+    return true;
 }
 
 /**
@@ -2729,53 +2865,53 @@ class Asm extends MacroFunction {
  */
 function initScope(scope) {
     // namespaces
-    scope.hardSet("ControlKind", new NamespaceMacro(scope));
+    scope.hardSet("ControlKind", new NamespaceMacro());
     scope.hardSet("Vars", new VarsNamespace(scope));
-    scope.hardSet("Teams", new NamespaceMacro(scope));
-    scope.hardSet("Items", new NamespaceMacro(scope, { changeCasing: true }));
-    scope.hardSet("Liquids", new NamespaceMacro(scope));
-    scope.hardSet("Units", new NamespaceMacro(scope, { changeCasing: true }));
-    scope.hardSet("LAccess", new NamespaceMacro(scope));
-    scope.hardSet("Blocks", new NamespaceMacro(scope, { changeCasing: true }));
+    scope.hardSet("Teams", new NamespaceMacro());
+    scope.hardSet("Items", new NamespaceMacro({ changeCasing: true }));
+    scope.hardSet("Liquids", new NamespaceMacro());
+    scope.hardSet("Units", new NamespaceMacro({ changeCasing: true }));
+    scope.hardSet("LAccess", new NamespaceMacro());
+    scope.hardSet("Blocks", new NamespaceMacro({ changeCasing: true }));
     // helper methods
-    scope.hardSet("getBuilding", new GetGlobal(scope, EMutability.constant));
-    scope.hardSet("getVar", new GetGlobal(scope, EMutability.mutable));
-    scope.hardSet("concat", new Concat(scope));
-    scope.hardSet("asm", new Asm(scope));
+    scope.hardSet("getBuilding", new GetGlobal(EMutability.constant));
+    scope.hardSet("getVar", new GetGlobal(EMutability.mutable));
+    scope.hardSet("concat", new Concat());
+    scope.hardSet("asm", new Asm());
     scope.hardSet("Math", new MlogMath(scope));
-    scope.hardSet("Memory", new MemoryBuilder(scope));
+    scope.hardSet("Memory", new MemoryBuilder());
     // commands
-    scope.hardSet("draw", new Draw(scope));
-    scope.hardSet("print", new Print(scope));
-    scope.hardSet("printFlush", new PrintFlush(scope));
-    scope.hardSet("drawFlush", new DrawFlush(scope));
-    scope.hardSet("getLink", new GetLink(scope));
-    scope.hardSet("control", new Control(scope));
-    scope.hardSet("radar", new Radar(scope));
-    scope.hardSet("sensor", new Sensor(scope));
-    scope.hardSet("wait", new Wait(scope));
-    scope.hardSet("lookup", new Lookup(scope));
-    scope.hardSet("packColor", new PackColor(scope));
-    scope.hardSet("endScript", new End(scope));
-    scope.hardSet("stopScript", new Stop(scope));
-    scope.hardSet("unitBind", new UnitBind(scope));
-    scope.hardSet("unitControl", new UnitControl(scope));
-    scope.hardSet("unitRadar", new UnitRadar(scope));
-    scope.hardSet("unitLocate", new UnitLocate(scope));
+    scope.hardSet("draw", new Draw());
+    scope.hardSet("print", new Print());
+    scope.hardSet("printFlush", new PrintFlush());
+    scope.hardSet("drawFlush", new DrawFlush());
+    scope.hardSet("getLink", new GetLink());
+    scope.hardSet("control", new Control());
+    scope.hardSet("radar", new Radar());
+    scope.hardSet("sensor", new Sensor());
+    scope.hardSet("wait", new Wait());
+    scope.hardSet("lookup", new Lookup());
+    scope.hardSet("packColor", new PackColor());
+    scope.hardSet("endScript", new End());
+    scope.hardSet("stopScript", new Stop());
+    scope.hardSet("unitBind", new UnitBind());
+    scope.hardSet("unitControl", new UnitControl());
+    scope.hardSet("unitRadar", new UnitRadar());
+    scope.hardSet("unitLocate", new UnitLocate());
     // world processor commands
-    scope.hardSet("getBlock", new GetBlock(scope));
-    scope.hardSet("setBlock", new SetBlock(scope));
-    scope.hardSet("spawnUnit", new SpawnUnit(scope));
-    scope.hardSet("applyStatus", new ApplyStatus(scope));
-    scope.hardSet("spawnWave", new SpawnWave(scope));
-    scope.hardSet("setRule", new SetRule(scope));
-    scope.hardSet("flushMessage", new FlushMessage(scope));
-    scope.hardSet("cutscene", new Cutscene(scope));
-    scope.hardSet("explosion", new Explosion(scope));
-    scope.hardSet("setRate", new SetRate(scope));
-    scope.hardSet("fetch", new Fetch(scope));
-    scope.hardSet("getFlag", new GetFlag(scope));
-    scope.hardSet("setFlag", new SetFlag(scope));
+    scope.hardSet("getBlock", new GetBlock());
+    scope.hardSet("setBlock", new SetBlock());
+    scope.hardSet("spawnUnit", new SpawnUnit());
+    scope.hardSet("applyStatus", new ApplyStatus());
+    scope.hardSet("spawnWave", new SpawnWave());
+    scope.hardSet("setRule", new SetRule());
+    scope.hardSet("flushMessage", new FlushMessage());
+    scope.hardSet("cutscene", new Cutscene());
+    scope.hardSet("explosion", new Explosion());
+    scope.hardSet("setRate", new SetRate());
+    scope.hardSet("fetch", new Fetch());
+    scope.hardSet("getFlag", new GetFlag());
+    scope.hardSet("setFlag", new SetFlag());
 }
 
 class Compiler {
@@ -2882,7 +3018,7 @@ class Compiler {
      */
     handleMany(scope, nodes, handler) {
         const lines = [];
-        for (const node of nodes) {
+        for (const node of hoistedFunctionNodes(nodes)) {
             const [, nodeLines] = this.handle(scope, node, handler && (() => handler(node)));
             lines.push(...nodeLines);
         }
@@ -2912,6 +3048,20 @@ function hideRedundantJumps(inst) {
             current = inst[searchIndex];
         }
     }
+}
+function* hoistedFunctionNodes(nodes) {
+    // sorting is O(n long n) while this is just O(n)
+    // besides, it's better not to modify the node array
+    for (const node of nodes) {
+        if (node.type === "FunctionDeclaration") {
+            yield node;
+        }
+    }
+    for (const node of nodes) {
+        if (node.type !== "FunctionDeclaration") {
+            yield node;
+        }
+    }
 }
 
 export { Compiler, CompilerError };