mlogjs 0.5.0 → 0.5.2

package/dist/Compiler.d.ts

@@ -22,6 +22,8 @@ export declare class Compiler {
     protected parse(script: string): import("@babel/parser").ParseResult<es.File>;
     protected mapSources(valueInst: TValueInstructions<IValue | null>): es.SourceLocation[];
     handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions<IValue | null>;
+    /** Handles the node and asserts that it resolves to a value. */
+    handleValue(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions;
     handleEval(scope: IScope, node: es.Node, out?: TEOutput): TValueInstructions;
     /**
      * Handles many nodes in order.

package/dist/index.cjs

@@ -230,6 +230,9 @@ class VoidValue {
         return;
     }
     postCall(_scope) { }
+    toOut() {
+        return this;
+    }
     debugString() {
         return "VoidValue";
     }
@@ -403,8 +406,8 @@ function extractOutName(out) {
     return out.name;
 }
 function extractDestrucuringOut(out, field) {
-    if (out === discardedName)
-        return out;
+    if (isDiscardedOut(out))
+        return discardedName;
     if (!(out instanceof DestructuringValue))
         return;
     return out.fields[field] ?? discardedName;
@@ -459,6 +462,13 @@ function assertObjectFields(value, fields) {
     }
     return result;
 }
+function isDiscardedOut(out) {
+    if (!out)
+        return false;
+    if (typeof out === "string")
+        return out === discardedName;
+    return out.name === discardedName;
+}
 
 class SetInstruction extends InstructionBase {
     constructor(store, value) {
@@ -540,7 +550,7 @@ class JumpInstruction extends InstructionBase {
         if (test === out)
             return [];
         return [
-            new JumpInstruction(out.address, EJumpKind.Equal, test, new LiteralValue(+out.whenTrue)),
+            new JumpInstruction(out.address, out.whenTrue ? EJumpKind.NotEqual : EJumpKind.Equal, test, new LiteralValue(0)),
         ];
     }
 }
@@ -642,8 +652,11 @@ class BaseValue extends VoidValue {
         ];
     }
     "u+"(scope, out) {
-        // TODO: should it return 0 + this ?
-        return this.eval(scope, out);
+        const inst = [];
+        const value = pipeInsts(this.eval(scope), inst);
+        const zero = new LiteralValue(0);
+        const result = pipeInsts(zero["+"](scope, value, out), inst);
+        return [result, inst];
     }
     "!"(scope, out) {
         const inst = [];
@@ -665,7 +678,7 @@ class BaseValue extends VoidValue {
         const endAdress = new LiteralValue(null);
         const [left, leftInst] = this.eval(scope, result);
         const [right, rightInst] = other.eval(scope, result);
-        const [test, testInst] = this["==="](scope, nullLiteral);
+        const [test, testInst] = left["==="](scope, nullLiteral);
         return [
             result,
             [
@@ -730,7 +743,7 @@ const assignmentToBinary = {
 for (const k in assignmentToBinary) {
     const op = k;
     BaseValue.prototype[op] = function (scope, value) {
-        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value, this);
+        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value, this.toOut());
         const [retValue, retInst] = this["="](scope, opValue);
         return [retValue, [...opInst, ...retInst]];
     };
@@ -738,9 +751,10 @@ for (const k in assignmentToBinary) {
 for (const key of updateOperators) {
     BaseValue.prototype[key] = function (scope, prefix, out) {
         let [ret, inst] = this.eval(scope);
-        if (!prefix && out !== discardedName) {
+        if (!prefix && !isDiscardedOut(out)) {
             const temp = StoreValue.from(scope, out);
-            ret = pipeInsts(temp["="](scope, ret), inst);
+            pipeInsts(temp["="](scope, ret), inst);
+            ret = temp;
         }
         const kind = key === "++" ? "+=" : "-=";
         pipeInsts(this[kind](scope, new LiteralValue(1)), inst);
@@ -897,7 +911,7 @@ class StoreValue extends BaseValue {
         const [evalValue, evalInst] = value.eval(scope, this);
         if (evalValue.macro)
             throw new CompilerError(`Cannot assign a macro to a store (attempted to assign [${evalValue.debugString()}] to [${this.debugString()}])`);
-        return [this, [...evalInst, new SetInstruction(this, evalValue)]];
+        return [evalValue, [...evalInst, new SetInstruction(this, evalValue)]];
     }
     "=="(scope, value, out) {
         if (compareStores(this, value))
@@ -1160,10 +1174,13 @@ class AssignmentValue extends VoidValue {
     }
     "="(scope, value, out) {
         const inst = [];
-        const input = pipeInsts(value["??"](scope, this.right, this.left), inst);
+        const input = pipeInsts(value["??"](scope, this.right, this.left.toOut()), inst);
         const output = pipeInsts(this.left["="](scope, input, out), inst);
         return [output, inst];
     }
+    toOut() {
+        return this.left.toOut();
+    }
     debugString() {
         return "AssignmentValue";
     }
@@ -1495,22 +1512,22 @@ const LogicalExpression = (c, scope, node, out) => {
     if (node.operator !== "??")
         return LRExpression(c, scope, node, out);
     const other = new LazyValue((scope, out) => c.handleEval(scope, node.right, out));
-    const [left, leftInst] = c.handleEval(scope, node.left);
+    const [left, leftInst] = c.handleValue(scope, node.left);
     const [result, resultInst] = left["??"](scope, other, out);
     return [result, [...leftInst, ...resultInst]];
 };
 const AssignmentExpression = (c, scope, node) => {
-    const [left, leftInst] = c.handle(scope, node.left);
+    const [left, leftInst] = c.handleValue(scope, node.left);
+    const leftOutput = left.toOut();
     const [right, rightInst] = node.operator !== "??="
-        ? c.handleEval(scope, node.right, node.operator === "=" && left ? left : undefined)
+        ? c.handleEval(scope, node.right, node.operator === "=" ? leftOutput : undefined)
         : [
             new LazyValue((scope, out) => c.handleEval(scope, node.right, out)),
             [],
         ];
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
-    if (left)
-        scope.clearDependentCache(left);
+    scope.clearDependentCache(left);
+    scope.clearDependentCache(leftOutput);
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const UnaryExpression = (c, scope, { argument, operator }, out) => {
@@ -1526,10 +1543,8 @@ const UnaryExpression = (c, scope, { argument, operator }, out) => {
     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 [arg, argInst] = c.handleValue(scope, argument);
+    scope.clearDependentCache(arg);
     const [op, opInst] = arg[operator](scope, prefix, out);
     return [op, [...argInst, ...opInst]];
 };
@@ -1679,7 +1694,9 @@ function asMergeableJumpNode(body) {
     if (body.type === "ContinueStatement" || body.type === "BreakStatement")
         return body;
     if (body.type !== "BlockStatement")
-        return undefined;
+        return;
+    if (body.body.length == 0)
+        return;
     return asMergeableJumpNode(body.body[0]);
 }
 
@@ -1961,7 +1978,7 @@ class FunctionValue extends VoidValue {
         for (let i = 0; i < this.params.length; i++) {
             const value = this.unwrapParameter(this.params[i]);
             this.paramValues.push(value);
-            this.paramOuts.push(value instanceof AssignmentValue ? value.left : value);
+            this.paramOuts.push(value.toOut());
             if (!(value instanceof AssignmentValue))
                 this.minimumArgumentCount = i + 1;
         }
@@ -2133,7 +2150,7 @@ class FunctionValue extends VoidValue {
                     const hasDefault = value instanceof AssignmentValue;
                     this.destructuringKeyData.set(key, { inst: propInst, value });
                     members.set(key, {
-                        value: hasDefault ? value.left : value,
+                        value: value.toOut(),
                         handler: (get, propExists, scope) => {
                             return this.c.handle(scope, prop, () => {
                                 const inst = [...propInst];
@@ -2164,7 +2181,7 @@ class FunctionValue extends VoidValue {
                     const key = new LiteralValue(i);
                     this.destructuringKeyData.set(key, { inst: [], value });
                     members.set(key, {
-                        value: hasDefault ? value.left : value,
+                        value: value.toOut(),
                         handler: (get, propExists, scope) => {
                             return this.c.handle(scope, element, () => {
                                 if (propExists() || !hasDefault) {
@@ -2379,12 +2396,10 @@ const ArrayPattern = (c, scope, node) => {
         const element = node.elements[i];
         if (!element)
             continue;
-        const value = pipeInsts(c.handle(scope, element), inst);
+        const value = pipeInsts(c.handleValue(scope, element), inst);
         const hasDefault = value instanceof AssignmentValue;
-        if (!value)
-            throw new CompilerError("Destructuring element must resolve to a value", element);
         members.set(new LiteralValue(i), {
-            value: hasDefault ? value.left : value,
+            value: value.toOut(),
             handler(get, propExists, scope) {
                 return c.handle(scope, element, () => {
                     if (propExists() || !hasDefault) {
@@ -2412,12 +2427,10 @@ const ObjectPattern = (c, scope, node) => {
         const [key, keyInst] = propKey.type === "Identifier" && !prop.computed
             ? [new LiteralValue(propKey.name), []]
             : c.handleEval(scope, propKey);
-        const value = pipeInsts(c.handle(scope, prop.value), inst);
+        const value = pipeInsts(c.handleValue(scope, prop.value), inst);
         const hasDefault = value instanceof AssignmentValue;
-        if (!value)
-            throw new CompilerError("Destructuring member must resolve to a value", prop.value);
         members.set(key, {
-            value: hasDefault ? value.left : value,
+            value: value.toOut(),
             handler(get, propExists, scope) {
                 return c.handle(scope, prop, () => {
                     const inst = keyInst;
@@ -2438,9 +2451,7 @@ const ObjectPattern = (c, scope, node) => {
 // the mlog runtime already does this check for us
 const OptionalMemberExpression = (c, scope, node, out) => MemberExpression(c, scope, node, out, true);
 const AssignmentPattern = (c, scope, node) => {
-    const [left, inst] = c.handle(scope, node.left);
-    if (!left)
-        throw new CompilerError("Left side of assignment pattern could not be resolved", node.left);
+    const [left, inst] = c.handleValue(scope, node.left);
     const right = new LazyValue((_, out) => c.handleEval(scope, node.right, out));
     return [new AssignmentValue(left, right), inst];
 };
@@ -2555,8 +2566,9 @@ var handlers = /*#__PURE__*/Object.freeze({
 });
 
 class MacroFunction extends VoidValue {
-    constructor(fn) {
+    constructor(fn, paramOuts) {
         super();
+        this.paramOuts = paramOuts;
         this.macro = true;
         this.mutability = EMutability.constant;
         this.fn = fn;
@@ -2567,6 +2579,9 @@ class MacroFunction extends VoidValue {
     eval(_scope) {
         return [this, []];
     }
+    preCall(_scope, _out) {
+        return this.paramOuts;
+    }
     debugString() {
         return "MacroFunction";
     }
@@ -2676,7 +2691,10 @@ class Concat extends MacroFunction {
             const [first] = values;
             if (!isTemplateObjectArray(first)) {
                 assertLiterals(values, "Concat arguments must be all literal values");
-                return [new LiteralValue(values.map(v => v.data).join("")), []];
+                let text = "";
+                for (const value of values)
+                    text += value.data;
+                return [new LiteralValue(text), []];
             }
             let text = "";
             const [, ...interpolated] = values;
@@ -3594,24 +3612,28 @@ class VarsNamespace extends NamespaceMacro {
 const itemSize = 2;
 class DynamicArray extends ObjectValue {
     constructor(scope, name, values, dynamic) {
-        const getterName = `${name}.&gtemp`;
-        const setterName = `${name}.&stemp`;
+        const getterName = `${name}.&read`;
+        const setterName = `${name}.&write`;
         const returnName = `${name}.&rt`;
         const lengthName = getLengthName(name);
         const lengthStore = new StoreValue(lengthName);
         const sizeValue = new LiteralValue(values.length);
         super({
-            // array[index]
             fill: new MacroFunction((scope, out, value) => {
+                if (!value)
+                    throw new CompilerError("Missing argument: value");
+                this.initFill();
                 const inst = [];
-                for (let i = 0; i < values.length; i++) {
-                    pipeInsts(values[i]["="](scope, value), inst);
-                }
+                const returnAddress = new LiteralValue(null);
+                pipeInsts(values[0]["="](scope, value), inst);
+                pipeInsts(this.returnTemp["="](scope, returnAddress), inst);
+                inst.push(new JumpInstruction(this.fillAddr, EJumpKind.Always));
+                inst.push(new AddressResolver(returnAddress));
                 if (this.lengthStore) {
                     pipeInsts(this.lengthStore["="](scope, new LiteralValue(values.length)), inst);
                 }
                 return [null, inst];
-            }),
+            }, [values[0]]),
             at: new MacroFunction((scope, out, index) => {
                 const inst = [];
                 const isLiteral = index instanceof LiteralValue;
@@ -3652,7 +3674,7 @@ class DynamicArray extends ObjectValue {
                         });
                         const [, inst] = entry["="](scope, item);
                         return [new LiteralValue(null), inst];
-                    }),
+                    }, [setterName]),
                     pop: new MacroFunction((scope, out) => {
                         const checked = scope.checkIndexes;
                         const inst = [];
@@ -3667,7 +3689,7 @@ class DynamicArray extends ObjectValue {
                             failAddress,
                         });
                         const nullLiteral = new LiteralValue(null);
-                        const hasOut = out !== discardedName;
+                        const hasOut = !isDiscardedOut(out);
                         const result = hasOut
                             ? pipeInsts(entry.eval(scope, out), inst)
                             : nullLiteral;
@@ -3686,7 +3708,7 @@ class DynamicArray extends ObjectValue {
                             assertBounds(index, 0, values.length - 1);
                         }
                         const checked = scope.checkIndexes;
-                        const hasOut = out !== discardedName;
+                        const hasOut = !isDiscardedOut(out);
                         const { returnTemp } = this;
                         const inst = [];
                         let result = new LiteralValue(null);
@@ -3736,6 +3758,7 @@ class DynamicArray extends ObjectValue {
         this.bundledSetter = false;
         this.bundledGetter = false;
         this.bundledRemoveAt = false;
+        this.bundledFill = false;
         this.scope = scope;
         this.name = name;
         this.values = values;
@@ -3747,6 +3770,7 @@ class DynamicArray extends ObjectValue {
         this.getterAddr = new LiteralValue(null);
         this.setterAddr = new LiteralValue(null);
         this.removeAtAddr = new LiteralValue(null);
+        this.fillAddr = new LiteralValue(null);
     }
     get(scope, index, out) {
         if (super.hasProperty(scope, index))
@@ -3806,6 +3830,19 @@ class DynamicArray extends ObjectValue {
         pipeInsts(last["="](this.scope, new LiteralValue(null)), inst);
         inst.push(new SetCounterInstruction(this.returnTemp));
     }
+    initFill() {
+        if (this.bundledFill)
+            return;
+        this.bundledFill = true;
+        const { inst } = this.scope;
+        inst.push(new AddressResolver(this.fillAddr));
+        const firstValue = this.values[0];
+        for (let i = 1; i < this.values.length; i++) {
+            const value = this.values[i];
+            pipeInsts(value["="](this.scope, firstValue), inst);
+        }
+        inst.push(new SetCounterInstruction(this.returnTemp));
+    }
     debugString() {
         const id = this.dynamic ? "DynamicArray" : "MutableArray";
         return `${id}("${this.name}")`;
@@ -3905,6 +3942,9 @@ class DynamicArrayEntry extends BaseValue {
             inst.push(new AddressResolver(failAddress));
         return [value, inst];
     }
+    toOut() {
+        return this.array.setterTemp;
+    }
     debugString() {
         const name = this.array.dynamic ? "DynamicArray" : "MutableArray";
         return `${name}Entry`;
@@ -4191,10 +4231,15 @@ class Compiler {
             throw error;
         }
     }
+    /** Handles the node and asserts that it resolves to a value. */
+    handleValue(scope, node, handler = this.handlers[node.type], out) {
+        const result = this.handle(scope, node, handler, out);
+        if (!result[0])
+            throw new CompilerError(`This node (${node.type}) did not return a value`, node);
+        return result;
+    }
     handleEval(scope, node, out) {
-        const [res, inst] = this.handle(scope, node, undefined, out);
-        if (!res)
-            throw new CompilerError(`This node (${node.type}) does not return a value`, node);
+        const [res, inst] = this.handleValue(scope, node, undefined, out);
         const [evaluated, evaluatedInst] = res.eval(scope, out);
         const result = [evaluated, [...inst, ...evaluatedInst]];
         if (this.sourcemap)

package/dist/index.mjs

@@ -209,6 +209,9 @@ class VoidValue {
         return;
     }
     postCall(_scope) { }
+    toOut() {
+        return this;
+    }
     debugString() {
         return "VoidValue";
     }
@@ -382,8 +385,8 @@ function extractOutName(out) {
     return out.name;
 }
 function extractDestrucuringOut(out, field) {
-    if (out === discardedName)
-        return out;
+    if (isDiscardedOut(out))
+        return discardedName;
     if (!(out instanceof DestructuringValue))
         return;
     return out.fields[field] ?? discardedName;
@@ -438,6 +441,13 @@ function assertObjectFields(value, fields) {
     }
     return result;
 }
+function isDiscardedOut(out) {
+    if (!out)
+        return false;
+    if (typeof out === "string")
+        return out === discardedName;
+    return out.name === discardedName;
+}
 
 class SetInstruction extends InstructionBase {
     constructor(store, value) {
@@ -519,7 +529,7 @@ class JumpInstruction extends InstructionBase {
         if (test === out)
             return [];
         return [
-            new JumpInstruction(out.address, EJumpKind.Equal, test, new LiteralValue(+out.whenTrue)),
+            new JumpInstruction(out.address, out.whenTrue ? EJumpKind.NotEqual : EJumpKind.Equal, test, new LiteralValue(0)),
         ];
     }
 }
@@ -621,8 +631,11 @@ class BaseValue extends VoidValue {
         ];
     }
     "u+"(scope, out) {
-        // TODO: should it return 0 + this ?
-        return this.eval(scope, out);
+        const inst = [];
+        const value = pipeInsts(this.eval(scope), inst);
+        const zero = new LiteralValue(0);
+        const result = pipeInsts(zero["+"](scope, value, out), inst);
+        return [result, inst];
     }
     "!"(scope, out) {
         const inst = [];
@@ -644,7 +657,7 @@ class BaseValue extends VoidValue {
         const endAdress = new LiteralValue(null);
         const [left, leftInst] = this.eval(scope, result);
         const [right, rightInst] = other.eval(scope, result);
-        const [test, testInst] = this["==="](scope, nullLiteral);
+        const [test, testInst] = left["==="](scope, nullLiteral);
         return [
             result,
             [
@@ -709,7 +722,7 @@ const assignmentToBinary = {
 for (const k in assignmentToBinary) {
     const op = k;
     BaseValue.prototype[op] = function (scope, value) {
-        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value, this);
+        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value, this.toOut());
         const [retValue, retInst] = this["="](scope, opValue);
         return [retValue, [...opInst, ...retInst]];
     };
@@ -717,9 +730,10 @@ for (const k in assignmentToBinary) {
 for (const key of updateOperators) {
     BaseValue.prototype[key] = function (scope, prefix, out) {
         let [ret, inst] = this.eval(scope);
-        if (!prefix && out !== discardedName) {
+        if (!prefix && !isDiscardedOut(out)) {
             const temp = StoreValue.from(scope, out);
-            ret = pipeInsts(temp["="](scope, ret), inst);
+            pipeInsts(temp["="](scope, ret), inst);
+            ret = temp;
         }
         const kind = key === "++" ? "+=" : "-=";
         pipeInsts(this[kind](scope, new LiteralValue(1)), inst);
@@ -876,7 +890,7 @@ class StoreValue extends BaseValue {
         const [evalValue, evalInst] = value.eval(scope, this);
         if (evalValue.macro)
             throw new CompilerError(`Cannot assign a macro to a store (attempted to assign [${evalValue.debugString()}] to [${this.debugString()}])`);
-        return [this, [...evalInst, new SetInstruction(this, evalValue)]];
+        return [evalValue, [...evalInst, new SetInstruction(this, evalValue)]];
     }
     "=="(scope, value, out) {
         if (compareStores(this, value))
@@ -1139,10 +1153,13 @@ class AssignmentValue extends VoidValue {
     }
     "="(scope, value, out) {
         const inst = [];
-        const input = pipeInsts(value["??"](scope, this.right, this.left), inst);
+        const input = pipeInsts(value["??"](scope, this.right, this.left.toOut()), inst);
         const output = pipeInsts(this.left["="](scope, input, out), inst);
         return [output, inst];
     }
+    toOut() {
+        return this.left.toOut();
+    }
     debugString() {
         return "AssignmentValue";
     }
@@ -1474,22 +1491,22 @@ const LogicalExpression = (c, scope, node, out) => {
     if (node.operator !== "??")
         return LRExpression(c, scope, node, out);
     const other = new LazyValue((scope, out) => c.handleEval(scope, node.right, out));
-    const [left, leftInst] = c.handleEval(scope, node.left);
+    const [left, leftInst] = c.handleValue(scope, node.left);
     const [result, resultInst] = left["??"](scope, other, out);
     return [result, [...leftInst, ...resultInst]];
 };
 const AssignmentExpression = (c, scope, node) => {
-    const [left, leftInst] = c.handle(scope, node.left);
+    const [left, leftInst] = c.handleValue(scope, node.left);
+    const leftOutput = left.toOut();
     const [right, rightInst] = node.operator !== "??="
-        ? c.handleEval(scope, node.right, node.operator === "=" && left ? left : undefined)
+        ? c.handleEval(scope, node.right, node.operator === "=" ? leftOutput : undefined)
         : [
             new LazyValue((scope, out) => c.handleEval(scope, node.right, out)),
             [],
         ];
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
-    if (left)
-        scope.clearDependentCache(left);
+    scope.clearDependentCache(left);
+    scope.clearDependentCache(leftOutput);
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const UnaryExpression = (c, scope, { argument, operator }, out) => {
@@ -1505,10 +1522,8 @@ const UnaryExpression = (c, scope, { argument, operator }, out) => {
     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 [arg, argInst] = c.handleValue(scope, argument);
+    scope.clearDependentCache(arg);
     const [op, opInst] = arg[operator](scope, prefix, out);
     return [op, [...argInst, ...opInst]];
 };
@@ -1658,7 +1673,9 @@ function asMergeableJumpNode(body) {
     if (body.type === "ContinueStatement" || body.type === "BreakStatement")
         return body;
     if (body.type !== "BlockStatement")
-        return undefined;
+        return;
+    if (body.body.length == 0)
+        return;
     return asMergeableJumpNode(body.body[0]);
 }
 
@@ -1940,7 +1957,7 @@ class FunctionValue extends VoidValue {
         for (let i = 0; i < this.params.length; i++) {
             const value = this.unwrapParameter(this.params[i]);
             this.paramValues.push(value);
-            this.paramOuts.push(value instanceof AssignmentValue ? value.left : value);
+            this.paramOuts.push(value.toOut());
             if (!(value instanceof AssignmentValue))
                 this.minimumArgumentCount = i + 1;
         }
@@ -2112,7 +2129,7 @@ class FunctionValue extends VoidValue {
                     const hasDefault = value instanceof AssignmentValue;
                     this.destructuringKeyData.set(key, { inst: propInst, value });
                     members.set(key, {
-                        value: hasDefault ? value.left : value,
+                        value: value.toOut(),
                         handler: (get, propExists, scope) => {
                             return this.c.handle(scope, prop, () => {
                                 const inst = [...propInst];
@@ -2143,7 +2160,7 @@ class FunctionValue extends VoidValue {
                     const key = new LiteralValue(i);
                     this.destructuringKeyData.set(key, { inst: [], value });
                     members.set(key, {
-                        value: hasDefault ? value.left : value,
+                        value: value.toOut(),
                         handler: (get, propExists, scope) => {
                             return this.c.handle(scope, element, () => {
                                 if (propExists() || !hasDefault) {
@@ -2358,12 +2375,10 @@ const ArrayPattern = (c, scope, node) => {
         const element = node.elements[i];
         if (!element)
             continue;
-        const value = pipeInsts(c.handle(scope, element), inst);
+        const value = pipeInsts(c.handleValue(scope, element), inst);
         const hasDefault = value instanceof AssignmentValue;
-        if (!value)
-            throw new CompilerError("Destructuring element must resolve to a value", element);
         members.set(new LiteralValue(i), {
-            value: hasDefault ? value.left : value,
+            value: value.toOut(),
             handler(get, propExists, scope) {
                 return c.handle(scope, element, () => {
                     if (propExists() || !hasDefault) {
@@ -2391,12 +2406,10 @@ const ObjectPattern = (c, scope, node) => {
         const [key, keyInst] = propKey.type === "Identifier" && !prop.computed
             ? [new LiteralValue(propKey.name), []]
             : c.handleEval(scope, propKey);
-        const value = pipeInsts(c.handle(scope, prop.value), inst);
+        const value = pipeInsts(c.handleValue(scope, prop.value), inst);
         const hasDefault = value instanceof AssignmentValue;
-        if (!value)
-            throw new CompilerError("Destructuring member must resolve to a value", prop.value);
         members.set(key, {
-            value: hasDefault ? value.left : value,
+            value: value.toOut(),
             handler(get, propExists, scope) {
                 return c.handle(scope, prop, () => {
                     const inst = keyInst;
@@ -2417,9 +2430,7 @@ const ObjectPattern = (c, scope, node) => {
 // the mlog runtime already does this check for us
 const OptionalMemberExpression = (c, scope, node, out) => MemberExpression(c, scope, node, out, true);
 const AssignmentPattern = (c, scope, node) => {
-    const [left, inst] = c.handle(scope, node.left);
-    if (!left)
-        throw new CompilerError("Left side of assignment pattern could not be resolved", node.left);
+    const [left, inst] = c.handleValue(scope, node.left);
     const right = new LazyValue((_, out) => c.handleEval(scope, node.right, out));
     return [new AssignmentValue(left, right), inst];
 };
@@ -2534,8 +2545,9 @@ var handlers = /*#__PURE__*/Object.freeze({
 });
 
 class MacroFunction extends VoidValue {
-    constructor(fn) {
+    constructor(fn, paramOuts) {
         super();
+        this.paramOuts = paramOuts;
         this.macro = true;
         this.mutability = EMutability.constant;
         this.fn = fn;
@@ -2546,6 +2558,9 @@ class MacroFunction extends VoidValue {
     eval(_scope) {
         return [this, []];
     }
+    preCall(_scope, _out) {
+        return this.paramOuts;
+    }
     debugString() {
         return "MacroFunction";
     }
@@ -2655,7 +2670,10 @@ class Concat extends MacroFunction {
             const [first] = values;
             if (!isTemplateObjectArray(first)) {
                 assertLiterals(values, "Concat arguments must be all literal values");
-                return [new LiteralValue(values.map(v => v.data).join("")), []];
+                let text = "";
+                for (const value of values)
+                    text += value.data;
+                return [new LiteralValue(text), []];
             }
             let text = "";
             const [, ...interpolated] = values;
@@ -3573,24 +3591,28 @@ class VarsNamespace extends NamespaceMacro {
 const itemSize = 2;
 class DynamicArray extends ObjectValue {
     constructor(scope, name, values, dynamic) {
-        const getterName = `${name}.&gtemp`;
-        const setterName = `${name}.&stemp`;
+        const getterName = `${name}.&read`;
+        const setterName = `${name}.&write`;
         const returnName = `${name}.&rt`;
         const lengthName = getLengthName(name);
         const lengthStore = new StoreValue(lengthName);
         const sizeValue = new LiteralValue(values.length);
         super({
-            // array[index]
             fill: new MacroFunction((scope, out, value) => {
+                if (!value)
+                    throw new CompilerError("Missing argument: value");
+                this.initFill();
                 const inst = [];
-                for (let i = 0; i < values.length; i++) {
-                    pipeInsts(values[i]["="](scope, value), inst);
-                }
+                const returnAddress = new LiteralValue(null);
+                pipeInsts(values[0]["="](scope, value), inst);
+                pipeInsts(this.returnTemp["="](scope, returnAddress), inst);
+                inst.push(new JumpInstruction(this.fillAddr, EJumpKind.Always));
+                inst.push(new AddressResolver(returnAddress));
                 if (this.lengthStore) {
                     pipeInsts(this.lengthStore["="](scope, new LiteralValue(values.length)), inst);
                 }
                 return [null, inst];
-            }),
+            }, [values[0]]),
             at: new MacroFunction((scope, out, index) => {
                 const inst = [];
                 const isLiteral = index instanceof LiteralValue;
@@ -3631,7 +3653,7 @@ class DynamicArray extends ObjectValue {
                         });
                         const [, inst] = entry["="](scope, item);
                         return [new LiteralValue(null), inst];
-                    }),
+                    }, [setterName]),
                     pop: new MacroFunction((scope, out) => {
                         const checked = scope.checkIndexes;
                         const inst = [];
@@ -3646,7 +3668,7 @@ class DynamicArray extends ObjectValue {
                             failAddress,
                         });
                         const nullLiteral = new LiteralValue(null);
-                        const hasOut = out !== discardedName;
+                        const hasOut = !isDiscardedOut(out);
                         const result = hasOut
                             ? pipeInsts(entry.eval(scope, out), inst)
                             : nullLiteral;
@@ -3665,7 +3687,7 @@ class DynamicArray extends ObjectValue {
                             assertBounds(index, 0, values.length - 1);
                         }
                         const checked = scope.checkIndexes;
-                        const hasOut = out !== discardedName;
+                        const hasOut = !isDiscardedOut(out);
                         const { returnTemp } = this;
                         const inst = [];
                         let result = new LiteralValue(null);
@@ -3715,6 +3737,7 @@ class DynamicArray extends ObjectValue {
         this.bundledSetter = false;
         this.bundledGetter = false;
         this.bundledRemoveAt = false;
+        this.bundledFill = false;
         this.scope = scope;
         this.name = name;
         this.values = values;
@@ -3726,6 +3749,7 @@ class DynamicArray extends ObjectValue {
         this.getterAddr = new LiteralValue(null);
         this.setterAddr = new LiteralValue(null);
         this.removeAtAddr = new LiteralValue(null);
+        this.fillAddr = new LiteralValue(null);
     }
     get(scope, index, out) {
         if (super.hasProperty(scope, index))
@@ -3785,6 +3809,19 @@ class DynamicArray extends ObjectValue {
         pipeInsts(last["="](this.scope, new LiteralValue(null)), inst);
         inst.push(new SetCounterInstruction(this.returnTemp));
     }
+    initFill() {
+        if (this.bundledFill)
+            return;
+        this.bundledFill = true;
+        const { inst } = this.scope;
+        inst.push(new AddressResolver(this.fillAddr));
+        const firstValue = this.values[0];
+        for (let i = 1; i < this.values.length; i++) {
+            const value = this.values[i];
+            pipeInsts(value["="](this.scope, firstValue), inst);
+        }
+        inst.push(new SetCounterInstruction(this.returnTemp));
+    }
     debugString() {
         const id = this.dynamic ? "DynamicArray" : "MutableArray";
         return `${id}("${this.name}")`;
@@ -3884,6 +3921,9 @@ class DynamicArrayEntry extends BaseValue {
             inst.push(new AddressResolver(failAddress));
         return [value, inst];
     }
+    toOut() {
+        return this.array.setterTemp;
+    }
     debugString() {
         const name = this.array.dynamic ? "DynamicArray" : "MutableArray";
         return `${name}Entry`;
@@ -4170,10 +4210,15 @@ class Compiler {
             throw error;
         }
     }
+    /** Handles the node and asserts that it resolves to a value. */
+    handleValue(scope, node, handler = this.handlers[node.type], out) {
+        const result = this.handle(scope, node, handler, out);
+        if (!result[0])
+            throw new CompilerError(`This node (${node.type}) did not return a value`, node);
+        return result;
+    }
     handleEval(scope, node, out) {
-        const [res, inst] = this.handle(scope, node, undefined, out);
-        if (!res)
-            throw new CompilerError(`This node (${node.type}) does not return a value`, node);
+        const [res, inst] = this.handleValue(scope, node, undefined, out);
         const [evaluated, evaluatedInst] = res.eval(scope, out);
         const result = [evaluated, [...inst, ...evaluatedInst]];
         if (this.sourcemap)

package/dist/macros/DynamicArray.d.ts

@@ -12,16 +12,19 @@ export declare class DynamicArray extends ObjectValue {
     getterAddr: LiteralValue<number | null>;
     setterAddr: LiteralValue<number | null>;
     removeAtAddr: LiteralValue<number | null>;
+    fillAddr: LiteralValue<number | null>;
     lengthStore?: StoreValue;
     bundledSetter: boolean;
     bundledGetter: boolean;
     bundledRemoveAt: boolean;
+    bundledFill: boolean;
     constructor(scope: IScope, name: string, values: IValue[], dynamic: boolean);
     get(scope: IScope, index: IValue, out?: TEOutput): TValueInstructions;
     hasProperty(scope: IScope, prop: IValue): boolean;
     initGetter(): void;
     initSetter(): void;
     initRemoveAt(): void;
+    initFill(): void;
     debugString(): string;
     toString(): string;
 }

package/dist/macros/Function.d.ts

@@ -2,12 +2,14 @@ import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../ty
 import { VoidValue } from "../values";
 type TFunction<T extends IValue | null> = (scope: IScope, out: TEOutput | undefined, ...args: IValue[]) => TValueInstructions<T>;
 export declare class MacroFunction<RT extends IValue | null = IValue> extends VoidValue {
+    paramOuts?: TEOutput[] | undefined;
     macro: boolean;
     mutability: EMutability;
     fn: TFunction<RT>;
-    constructor(fn: TFunction<RT>);
+    constructor(fn: TFunction<RT>, paramOuts?: TEOutput[] | undefined);
     call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<RT>;
     eval(_scope: IScope): TValueInstructions;
+    preCall(_scope: IScope, _out?: TEOutput | undefined): readonly TEOutput[] | undefined;
     debugString(): string;
     toString(): string;
 }

package/dist/types.d.ts

@@ -236,6 +236,11 @@ export interface IValue extends IValueOperators {
     postCall(scope: IScope): void;
     /** The string representation of `this` in error messages. */
     debugString(): string;
+    /**
+     * Allows some values to choose alternative representations
+     * when they are used as operation outputs.
+     */
+    toOut(): IValue;
 }
 /** Helper type that is used in some typescript assertions */
 export interface INamedValue extends IValue {

package/dist/utils/value.d.ts

@@ -38,3 +38,4 @@ export interface IParameterDescriptor {
 }
 /** Asserts that all of the fields described are present on `value`*/
 export declare function assertObjectFields(value: ObjectValue, fields: (string | IParameterDescriptor)[]): (IValue | string)[];
+export declare function isDiscardedOut(out: TEOutput | undefined): boolean;

package/dist/values/AssignmentValue.d.ts

@@ -5,6 +5,7 @@ export declare class AssignmentValue extends VoidValue {
     right: IValue;
     constructor(left: IValue, right: IValue);
     "="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    toOut(): IValue;
     debugString(): string;
     toString(): string;
 }

package/dist/values/VoidValue.d.ts

@@ -9,6 +9,7 @@ export declare class VoidValue implements IValue {
     hasProperty(_scope: IScope, _prop: IValue): boolean;
     preCall(_scope: IScope, _out?: TEOutput): readonly TEOutput[] | undefined;
     postCall(_scope: IScope): void;
+    toOut(): IValue;
     debugString(): string;
     toString(): string;
 }

package/lib/commands.d.ts

@@ -560,6 +560,8 @@ declare global {
 
     /**
      * Makes the unit bound to this processor move to the enemy spawn
+     *
+     * @deprecated This command is no longer available in mindustry v7.
      */
     function pathfind(): void;
 

package/lib/helpers.d.ts

@@ -20,6 +20,8 @@ declare function getBuilding<T extends BasicBuilding = AnyBuilding>(
   name: string
 ): T;
 
+type ConcatLiteral = string | number | boolean | undefined;
+
 /**
  * Concatenates a list of constant literal values.
  *
@@ -34,9 +36,7 @@ declare function getBuilding<T extends BasicBuilding = AnyBuilding>(
  * ```
  */
 declare function concat(
-  ...args:
-    | (string | number | undefined)[]
-    | [TemplateStringsArray, ...(string | number | undefined)[]]
+  ...args: ConcatLiteral[] | [TemplateStringsArray, ...ConcatLiteral[]]
 ): string;
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlogjs",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Compiler that compiles Javascript to Mindustry Logic Code.",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",