@markw65/monkeyc-optimizer 1.0.16 → 1.0.19

package/build/optimizer.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,get_jungle,launchSimulator,manifestProducts,mctree,simulateProgram,defaultConfig,isErrorWithLocation,buildOptimizedProject,generateOptimizedProject,getProjectAnalysis,generateApiMirTests});
+0 && (module.exports = {buildOptimizedProject,copyRecursiveAsNeeded,defaultConfig,generateApiMirTests,generateOptimizedProject,getProjectAnalysis,get_jungle,isErrorWithLocation,launchSimulator,manifestProducts,mctree,simulateProgram});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -10791,11 +10791,67 @@ function simulateProgram(prg, device, test) {
     return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", "monkeydo"), args, (line) => console.log(line)).then(() => { }));
 }
 
+;// CONCATENATED MODULE: ./src/variable-renamer.ts
+
+function renameVariable(state, locals, declName) {
+    const map = locals.map;
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, declName))
+        return null;
+    let suffix = 0;
+    let node_name = declName;
+    const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
+    if (match) {
+        node_name = match[1];
+        suffix = parseInt(match[2], 10) + 1;
+    }
+    if (!locals.inners) {
+        // find all the names declared in this scope, to avoid
+        // more conflicts
+        locals.inners = {};
+        const inners = locals.inners;
+        (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
+            if (node.type === "VariableDeclarator") {
+                inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
+            }
+        });
+    }
+    let name;
+    while (true) {
+        name = `pmcr_${node_name}_${suffix}`;
+        if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, name) && !(0,external_api_cjs_namespaceObject.hasProperty)(locals.inners, name)) {
+            // we also need to ensure that we don't hide the name of
+            // an outer module, class, function, enum or variable,
+            // since someone might want to access it from this scope.
+            let ok = false;
+            let i;
+            for (i = state.stack.length; i--;) {
+                const elm = state.stack[i];
+                if (ok) {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(elm.decls, name)) {
+                        break;
+                    }
+                }
+                else if (elm.node && elm.node.type === "FunctionDeclaration") {
+                    ok = true;
+                }
+            }
+            if (i < 0) {
+                break;
+            }
+        }
+        suffix++;
+    }
+    map[declName] = name;
+    map[name] = true;
+    return name;
+}
+
 ;// CONCATENATED MODULE: ./src/inliner.ts
 
-function canInline(state, func, args) {
+
+function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
-    // during the evaluation of FunctionStateNode.
+    // or assignment during the evaluation of FunctionStateNode.
     const getSafety = (decl) => {
         // enums are constant, they cant change
         if (decl.type === "EnumStringMember")
@@ -10825,22 +10881,28 @@ function canInline(state, func, args) {
             case "Identifier":
             case "MemberExpression": {
                 const [, results] = state.lookup(arg);
-                if (!results || results.length !== 1)
-                    return false;
+                if (!results || results.length !== 1) {
+                    safeArgs.push(null);
+                    return !requireAll;
+                }
                 const safety = getSafety(results[0]);
-                if (safety === null)
-                    return false;
-                if (!safety)
-                    allSafe = false;
                 safeArgs.push(safety);
+                if (!safety) {
+                    allSafe = false;
+                    if (safety === null) {
+                        return !requireAll;
+                    }
+                }
                 return true;
             }
         }
-        return false;
+        allSafe = false;
+        safeArgs.push(null);
+        return !requireAll;
     })) {
         return false;
     }
-    if (allSafe)
+    if (allSafe && requireAll)
         return true;
     let callSeen = false;
     let ok = true;
@@ -10863,6 +10925,14 @@ function canInline(state, func, args) {
             .map(([key]) => key);
     }, (node) => {
         switch (node.type) {
+            case "AssignmentExpression":
+            case "UpdateExpression": {
+                const v = node.type == "UpdateExpression" ? node.argument : node.left;
+                if (v.type === "Identifier" && (0,external_api_cjs_namespaceObject.hasProperty)(params, v.name)) {
+                    safeArgs[params[v.name]] = null;
+                }
+            }
+            // fall through
             case "CallExpression":
             case "NewExpression":
                 callSeen = true;
@@ -10871,11 +10941,18 @@ function canInline(state, func, args) {
                 if (callSeen &&
                     (0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
                     !safeArgs[params[node.name]]) {
-                    ok = false;
+                    safeArgs[params[node.name]] = null;
                 }
         }
     });
-    return ok;
+    return safeArgs;
+}
+function canInline(state, func, args) {
+    const safeArgs = getArgSafety(state, func, args, true);
+    if (safeArgs === true || safeArgs === false) {
+        return safeArgs;
+    }
+    return safeArgs.every((arg) => arg !== null);
 }
 function inliningLooksUseful(func, node) {
     while (true) {
@@ -10900,77 +10977,288 @@ function inliningLooksUseful(func, node) {
     }
     return false;
 }
-function shouldInline(state, func, args) {
-    if (!func.node.body ||
-        func.node.body.body.length !== 1 ||
-        func.node.body.body[0].type !== "ReturnStatement" ||
-        !func.node.body.body[0].argument ||
-        func.node.params.length !== args.length) {
-        return false;
-    }
-    const autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
+var InlineStatus;
+(function (InlineStatus) {
+    InlineStatus[InlineStatus["Never"] = 0] = "Never";
+    InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
+    InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
+})(InlineStatus || (InlineStatus = {}));
+function inlineRequested(state, func) {
     const excludeAnnotations = (func.node.loc?.source &&
-        state.fnMap[func.node.loc?.source].excludeAnnotations) ||
+        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
         {};
-    return ((autoInline ||
-        (func.node.attrs &&
-            func.node.attrs.attrs &&
-            func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
-                (attr.argument.name === "inline" ||
-                    (attr.argument.name.startsWith("inline_") &&
-                        (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7))))))) &&
-        (autoInline === 1 || canInline(state, func, args)));
-}
-function inlineFunction(state, func, call) {
-    const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
-    const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
+    if (func.node.attrs &&
+        func.node.attrs.attrs &&
+        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+            (attr.argument.name === "inline" ||
+                (attr.argument.name.startsWith("inline_") &&
+                    (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7)))))) {
+        return true;
+    }
+    return false;
+}
+function shouldInline(state, func, call, context) {
+    let autoInline = false;
+    let inlineAsExpression = false;
+    const args = call.arguments;
+    if (func.node.body &&
+        func.node.body.body.length === 1 &&
+        func.node.body.body[0].type === "ReturnStatement" &&
+        func.node.body.body[0].argument &&
+        func.node.params.length === args.length) {
+        inlineAsExpression = true;
+        autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
+    }
+    if (autoInline === 1) {
+        return true;
+    }
+    const requested = inlineRequested(state, func);
+    if (autoInline || requested) {
+        if (inlineAsExpression) {
+            if (canInline(state, func, args)) {
+                return true;
+            }
+        }
+        if (!context && requested) {
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+        }
+        return context != null;
+    }
+    return false;
+}
+function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
+    let failed = false;
+    const pre = state.pre;
+    const post = state.post;
     try {
-        const result = (0,external_api_cjs_namespaceObject.traverseAst)(retArg, (node) => {
-            switch (node.type) {
-                case "MemberExpression":
-                    if (!node.computed) {
-                        return ["object"];
-                    }
-                    break;
-                case "BinaryExpression":
-                    if (node.operator === "as") {
-                        return ["left"];
-                    }
-                    break;
-                case "UnaryExpression":
-                    if (node.operator === " as") {
-                        return [];
-                    }
+        state.pre = (node) => {
+            if (failed)
+                return [];
+            node.start = call.start;
+            node.end = call.end;
+            node.loc = call.loc;
+            if (node === insertedVariableDecls)
+                return false;
+            const result = pre(node, state);
+            if (!insertedVariableDecls && node.type === "BlockStatement") {
+                const locals = state.localsStack[state.localsStack.length - 1];
+                const { map } = locals;
+                if (!map)
+                    throw new Error("No local variable map!");
+                // We still need to keep track of every local name that was
+                // already in use, but we don't want to use any of its renames.
+                // We also want to know whether a local is from the function being
+                // inlined, or the calling function, so set every element to false.
+                Object.keys(map).forEach((key) => (map[key] = false));
+                const declarations = func.node.params
+                    .map((param, i) => {
+                    const paramName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
+                    if (params[paramName] >= 0)
+                        return null;
+                    const name = renameVariable(state, locals, paramName) || paramName;
+                    return {
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name },
+                        kind: "var",
+                        init: call.arguments[i],
+                    };
+                })
+                    .filter((n) => n != null);
+                insertedVariableDecls = {
+                    type: "VariableDeclaration",
+                    declarations,
+                    kind: "var",
+                };
+                node.body.unshift(insertedVariableDecls);
             }
-            return null;
-        }, (node) => {
+            return result;
+        };
+        state.post = (node) => {
+            if (failed)
+                return null;
+            let replacement = null;
             switch (node.type) {
                 case "Identifier": {
+                    if (state.inType)
+                        break;
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
-                        return call.arguments[params[node.name]];
+                        const ix = params[node.name];
+                        if (ix >= 0) {
+                            replacement = call.arguments[ix];
+                        }
+                        break;
                     }
-                    const rep = fixNodeScope(state, node, func.stack);
-                    if (!rep) {
-                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                    replacement = fixNodeScope(state, node, func.stack);
+                    if (!replacement) {
+                        failed = true;
+                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+                        return null;
                     }
-                    return rep;
+                    break;
                 }
             }
+            return post(replacement || node, state) || replacement;
+        };
+        let ret = state.traverse(root);
+        if (failed) {
             return null;
-        }) || retArg;
-        result.loc = call.loc;
-        result.start = call.start;
-        result.end = call.end;
-        return result;
+        }
+        if (ret === null) {
+            ret = root;
+        }
+        if (!ret) {
+            inlineDiagnostic(state, func, call, `Internal error`);
+            return null;
+        }
+        inlineDiagnostic(state, func, call, null);
+        return ret;
     }
-    catch (ex) {
-        if (ex instanceof Error) {
-            if (ex.message.startsWith("Inliner: ")) {
+    finally {
+        state.pre = pre;
+        state.post = post;
+    }
+}
+function unused(expression, top) {
+    switch (expression.type) {
+        case "Literal":
+            return [];
+        case "Identifier":
+            return [];
+        case "BinaryExpression":
+            if (expression.operator === "as") {
+                return unused(expression.left);
+            }
+        // fall through
+        case "LogicalExpression":
+            return unused(expression.left).concat(unused(expression.right));
+        case "UnaryExpression":
+            return unused(expression.argument);
+        case "MemberExpression":
+            if (expression.computed) {
+                return unused(expression.object).concat(unused(expression.property));
+            }
+            return unused(expression.object);
+        case "ArrayExpression":
+            return expression.elements.map((e) => unused(e)).flat(1);
+        case "ObjectExpression":
+            return expression.properties
+                .map((p) => unused(p.key).concat(unused(p.value)))
+                .flat(1);
+    }
+    return top
+        ? null
+        : [
+            {
+                type: "ExpressionStatement",
+                expression,
+                start: expression.start,
+                end: expression.end,
+                loc: expression.loc,
+            },
+        ];
+}
+function diagnostic(state, loc, message) {
+    if (!loc || !loc.source)
+        return;
+    const source = loc.source;
+    if (!state.diagnostics)
+        state.diagnostics = {};
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.diagnostics, source)) {
+        if (!message)
+            return;
+        state.diagnostics[source] = [];
+    }
+    const diags = state.diagnostics[source];
+    let index = diags.findIndex((item) => item.loc === loc);
+    if (message) {
+        if (index < 0)
+            index = diags.length;
+        diags[index] = { type: "INFO", loc, message };
+    }
+    else if (index >= 0) {
+        diags.splice(index, 1);
+    }
+}
+function inlineDiagnostic(state, func, call, message) {
+    if (inlineRequested(state, func)) {
+        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+    }
+}
+function inlineWithArgs(state, func, call, context) {
+    if (!func.node || !func.node.body) {
+        return null;
+    }
+    let retStmtCount = 0;
+    if (context.type === "ReturnStatement") {
+        const last = func.node.body.body.slice(-1)[0];
+        if (!last || last.type !== "ReturnStatement") {
+            inlineDiagnostic(state, func, call, "Function didn't end with a return statement");
+            return null;
+        }
+    }
+    else {
+        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+            node.type === "ReturnStatement" && retStmtCount++;
+        });
+        if (retStmtCount > 1) {
+            inlineDiagnostic(state, func, call, "Function had more than one return statement");
+        }
+        else if (context.type === "AssignmentExpression" && retStmtCount !== 1) {
+            inlineDiagnostic(state, func, call, "Function did not have a return statement");
+            return null;
+        }
+        if (retStmtCount === 1) {
+            const last = func.node.body.body.slice(-1)[0];
+            if (!last ||
+                last.type !== "ReturnStatement" ||
+                (context.type === "AssignmentExpression" && !last.argument)) {
+                inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
                 return null;
             }
         }
-        throw ex;
     }
+    const body = JSON.parse(JSON.stringify(func.node.body));
+    const safeArgs = getArgSafety(state, func, call.arguments, false);
+    const params = Object.fromEntries(func.node.params.map((param, i) => {
+        const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
+            ? i
+            : -1;
+        const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
+        return [name, argnum];
+    }));
+    if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
+        return null;
+    }
+    diagnostic(state, call.loc, null);
+    if (context.type !== "ReturnStatement" && retStmtCount) {
+        const last = body.body[body.body.length - 1];
+        if (last.type != "ReturnStatement") {
+            throw new Error("ReturnStatement got lost!");
+        }
+        if (context.type === "AssignmentExpression") {
+            context.right = last.argument;
+            body.body[body.body.length - 1] = {
+                type: "ExpressionStatement",
+                expression: context,
+            };
+        }
+        else if (last.argument) {
+            const side_exprs = unused(last.argument);
+            body.body.splice(body.body.length - 1, 1, ...side_exprs);
+        }
+        else {
+            --body.body.length;
+        }
+    }
+    return body;
+}
+function inlineFunction(state, func, call, context) {
+    if (context) {
+        return inlineWithArgs(state, func, call, context);
+    }
+    const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
+    const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
+    return processInlineBody(state, func, call, retArg, true, params);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -10984,6 +11272,17 @@ function applyTypeIfNeeded(node) {
     return node;
 }
 function fixNodeScope(state, lookupNode, nodeStack) {
+    if (lookupNode.type === "Identifier") {
+        const locals = state.localsStack[state.localsStack.length - 1];
+        const { map } = locals;
+        if (!map)
+            throw new Error("No local variable map!");
+        if ((0,external_api_cjs_namespaceObject.hasProperty)(map, lookupNode.name) && map[lookupNode.name] !== false) {
+            // map[name] !== false means its an entry that was created during inlining
+            // so its definitely one of our locals.
+            return lookupNode;
+        }
+    }
     const [, original] = state.lookup(lookupNode, null, nodeStack);
     if (!original) {
         return null;
@@ -11067,6 +11366,7 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 
 
 
+
 function processImports(allImports, lookup) {
     allImports.forEach(({ node, stack }) => {
         const [name, module] = lookup(node.id, ("as" in node && node.as && node.as.name) || null, stack);
@@ -11080,10 +11380,13 @@ function processImports(allImports, lookup) {
             module.forEach((m) => {
                 if ((0,external_api_cjs_namespaceObject.isStateNode)(m) && m.type == "ModuleDeclaration") {
                     (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], m);
+                    if (!parent.type_decls)
+                        parent.type_decls = {};
+                    const tdecls = parent.type_decls;
+                    if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
+                        tdecls[name] = [];
+                    (0,external_util_cjs_namespaceObject.pushUnique)(tdecls[name], m);
                     if (node.type == "ImportModule" && m.type_decls) {
-                        if (!parent.type_decls)
-                            parent.type_decls = {};
-                        const tdecls = parent.type_decls;
                         Object.entries(m.type_decls).forEach(([name, decls]) => {
                             if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
                                 tdecls[name] = [];
@@ -11450,13 +11753,15 @@ function optimizeNode(node) {
     return null;
 }
 function evaluateFunction(func, args) {
-    if (args && args.length != func.params.length) {
+    if (!func.body || (args && args.length != func.params.length)) {
         return false;
     }
     const paramValues = args &&
         Object.fromEntries(func.params.map((p, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(p), args[i]]));
     let ret = null;
-    const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+    const body = args
+        ? JSON.parse(JSON.stringify(func.body))
+        : func.body;
     try {
         (0,external_api_cjs_namespaceObject.traverseAst)(body, (node) => {
             switch (node.type) {
@@ -11624,57 +11929,8 @@ async function optimizeMonkeyC(fnMap) {
                 const { map } = locals;
                 if (map) {
                     const declName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id);
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(map, declName)) {
-                        // We already have a variable with this name in scope
-                        // Recent monkeyc compilers complain, so rename it
-                        let suffix = 0;
-                        let node_name = declName;
-                        const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
-                        if (match) {
-                            node_name = match[1];
-                            suffix = parseInt(match[2], 10) + 1;
-                        }
-                        if (!locals.inners) {
-                            // find all the names declared in this scope, to avoid
-                            // more conflicts
-                            locals.inners = {};
-                            const inners = locals.inners;
-                            (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
-                                if (node.type === "VariableDeclarator") {
-                                    inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
-                                }
-                            });
-                        }
-                        let name;
-                        while (true) {
-                            name = `pmcr_${node_name}_${suffix}`;
-                            if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, name) &&
-                                !(0,external_api_cjs_namespaceObject.hasProperty)(locals.inners, name)) {
-                                // we also need to ensure that we don't hide the name of
-                                // an outer module, class, function, enum or variable,
-                                // since someone might want to access it from this scope.
-                                let ok = false;
-                                let i;
-                                for (i = state.stack.length; i--;) {
-                                    const elm = state.stack[i];
-                                    if (ok) {
-                                        if ((0,external_api_cjs_namespaceObject.hasProperty)(elm.decls, name)) {
-                                            break;
-                                        }
-                                    }
-                                    else if (elm.node &&
-                                        elm.node.type === "FunctionDeclaration") {
-                                        ok = true;
-                                    }
-                                }
-                                if (i < 0) {
-                                    break;
-                                }
-                            }
-                            suffix++;
-                        }
-                        map[declName] = name;
-                        map[name] = true;
+                    const name = renameVariable(state, locals, declName);
+                    if (name) {
                         if (node.id.type === "Identifier") {
                             node.id.name = name;
                         }
@@ -11698,7 +11954,7 @@ async function optimizeMonkeyC(fnMap) {
                     state.exposed[node.argument.name] = true;
                     // In any case, we can't replace *this* use of the
                     // symbol with its value...
-                    return false;
+                    return [];
                 }
                 break;
             case "Identifier": {
@@ -11706,7 +11962,7 @@ async function optimizeMonkeyC(fnMap) {
                 if (map) {
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
                         const name = map[node.name];
-                        if (name !== true) {
+                        if (typeof name === "string") {
                             node.name = name;
                         }
                     }
@@ -11716,7 +11972,7 @@ async function optimizeMonkeyC(fnMap) {
                         state.exposed[node.name] = true;
                     }
                 }
-                return false;
+                return [];
             }
             case "MemberExpression":
                 if (node.property.type === "Identifier" && !node.computed) {
@@ -11797,49 +12053,58 @@ async function optimizeMonkeyC(fnMap) {
                     return node.body;
                 }
                 break;
+            case "ReturnStatement":
+                if (node.argument && node.argument.type === "CallExpression") {
+                    return optimizeCall(state, node.argument, node);
+                }
+                break;
             case "CallExpression": {
-                const [name, callees] = state.lookup(node.callee);
-                if (!callees || !callees.length) {
-                    const n = name ||
-                        ("name" in node.callee && node.callee.name) ||
-                        ("property" in node.callee &&
-                            node.callee.property &&
-                            "name" in node.callee.property &&
-                            node.callee.property.name);
-                    if (n) {
-                        state.exposed[n] = true;
-                    }
-                    else {
-                        // There are unnamed CallExpressions, such as new [size]
-                        // So there's nothing to do here.
-                    }
-                    return null;
+                const ret = optimizeCall(state, node, null);
+                if (ret) {
+                    replace(node, ret);
                 }
-                if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
-                    const callee = callees[0].node;
-                    if (callee.optimizable &&
-                        !callee.hasOverride &&
-                        node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
-                        const ret = evaluateFunction(callee, node.arguments);
-                        if (ret) {
-                            replace(node, ret);
-                            return null;
+                break;
+            }
+            case "AssignmentExpression":
+                if (node.operator === "=" &&
+                    node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    return { type: "Literal", value: null, raw: "null" };
+                }
+                break;
+            case "ExpressionStatement":
+                if (node.expression.type === "CallExpression") {
+                    return optimizeCall(state, node.expression, node);
+                }
+                else if (node.expression.type === "AssignmentExpression") {
+                    if (node.expression.right.type === "CallExpression") {
+                        let ok = false;
+                        if (node.expression.left.type === "Identifier") {
+                            if ((0,external_api_cjs_namespaceObject.hasProperty)(topLocals().map, node.expression.left.type)) {
+                                ok = true;
+                            }
                         }
-                    }
-                    if (shouldInline(state, callees[0], node.arguments)) {
-                        const ret = inlineFunction(state, callees[0], node);
-                        if (ret) {
-                            replace(node, ret);
-                            return null;
+                        if (!ok && node.expression.operator == "=") {
+                            const [, result] = state.lookup(node.expression.left);
+                            ok = result != null;
+                        }
+                        if (ok) {
+                            const ret = optimizeCall(state, node.expression.right, node.expression);
+                            if (ret && ret.type === "BlockStatement") {
+                                const r2 = state.traverse(ret);
+                                return r2 === false || r2 ? r2 : ret;
+                            }
                         }
                     }
                 }
-                if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
-                    state.calledFunctions[name] = [];
+                else {
+                    const ret = unused(node.expression, true);
+                    if (ret) {
+                        return ret;
+                    }
                 }
-                callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && state.calledFunctions[name].push(c.node));
                 break;
-            }
         }
         return null;
     };
@@ -11921,6 +12186,111 @@ async function optimizeMonkeyC(fnMap) {
             return ret;
         });
     });
+    return state.diagnostics;
+}
+function optimizeCall(state, node, context) {
+    const [name, callees] = state.lookup(node.callee);
+    if (!callees || !callees.length) {
+        const n = name ||
+            ("name" in node.callee && node.callee.name) ||
+            ("property" in node.callee &&
+                node.callee.property &&
+                "name" in node.callee.property &&
+                node.callee.property.name);
+        if (n) {
+            state.exposed[n] = true;
+        }
+        else {
+            // There are unnamed CallExpressions, such as new [size]
+            // So there's nothing to do here.
+        }
+        return null;
+    }
+    if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
+        const callee = callees[0].node;
+        if (!context &&
+            callee.optimizable &&
+            !callee.hasOverride &&
+            node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
+            const ret = evaluateFunction(callee, node.arguments);
+            if (ret) {
+                return ret;
+            }
+        }
+        if (shouldInline(state, callees[0], node, context)) {
+            const ret = inlineFunction(state, callees[0], node, context);
+            if (ret) {
+                return ret;
+            }
+        }
+    }
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
+        state.calledFunctions[name] = [];
+    }
+    callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && (0,external_util_cjs_namespaceObject.pushUnique)(state.calledFunctions[name], c.node));
+    return null;
+}
+
+;// CONCATENATED MODULE: ./src/pragma-checker.ts
+
+function pragmaChecker(ast) {
+    const comments = ast.comments;
+    if (!comments)
+        return;
+    let index = -1;
+    let comment;
+    let matchers;
+    const next = () => {
+        while (++index < comments.length) {
+            comment = comments[index];
+            let match = comment.value.match(/^\s*@match\s+(.+)/);
+            if (!match)
+                continue;
+            let str = match[1];
+            matchers = [];
+            while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
+                matchers.push({ quote: match[1], needle: match[2] });
+                str = str.substring(match[0].length);
+                if (!str.length)
+                    break;
+            }
+            if (!str.length)
+                break;
+            if (!matchers.length) {
+                match = str.match(/^(\S+)\s+$/);
+                if (match) {
+                    matchers.push({ quote: '"', needle: match[1] });
+                    break;
+                }
+            }
+            throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
+        }
+    };
+    next();
+    (0,external_api_cjs_namespaceObject.traverseAst)(ast, (node) => {
+        if (index >= comments.length)
+            return false;
+        if (node.start && node.start >= (comment.end || Infinity)) {
+            const { quote, needle } = matchers.shift();
+            const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/[\r\n]/g, " ");
+            let found = false;
+            if (quote == '"') {
+                found = haystack.includes(needle);
+            }
+            else {
+                const re = new RegExp(needle);
+                found = re.test(haystack);
+            }
+            if (!found) {
+                throw new Error(`Didn't find '${needle}' at ${comment.loc.source}:${comment.loc.start.line}`);
+            }
+            if (!matchers.length) {
+                next();
+            }
+            return false;
+        }
+        return null;
+    });
 }
 
 ;// CONCATENATED MODULE: ./src/optimizer.ts
@@ -11937,6 +12307,7 @@ async function optimizeMonkeyC(fnMap) {
 
 
 
+
 function relative_path_no_dotdot(relative) {
     return relative.replace(/^(\.\.[\\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
 }
@@ -12005,7 +12376,7 @@ async function buildOptimizedProject(product, options) {
             config.releaseBuild = true;
         }
     }
-    const { jungleFiles, program, hasTests } = await generateOptimizedProject(config);
+    const { jungleFiles, program, hasTests, diagnostics } = await generateOptimizedProject(config);
     config.jungleFiles = jungleFiles;
     let bin = config.buildDir || "bin";
     let name = `optimized-${program}.prg`;
@@ -12024,6 +12395,7 @@ async function buildOptimizedProject(product, options) {
         delete config.testBuild;
     return build_project(product, config).then((result) => ({
         hasTests,
+        diagnostics,
         ...result,
     }));
 }
@@ -12162,6 +12534,7 @@ async function generateOptimizedProject(options) {
         (await checkManifest(xml, targets.map((t) => t.product)))) &&
         !dropBarrels;
     let hasTests = false;
+    let diagnostics = {};
     const promises = Object.keys(buildConfigs)
         .sort()
         .map((key) => {
@@ -12179,7 +12552,13 @@ async function generateOptimizedProject(options) {
                 e.products = products[key];
                 throw e;
             })
-                .then((t) => t && (hasTests = true))
+                .then((t) => {
+                if (t.hasTests)
+                    hasTests = true;
+                if (t.diagnostics) {
+                    diagnostics = { ...diagnostics, ...t.diagnostics };
+                }
+            })
             : promises_namespaceObject.rm(external_path_.resolve(workspace, outputPath), {
                 recursive: true,
                 force: true,
@@ -12250,6 +12629,7 @@ async function generateOptimizedProject(options) {
         xml,
         program: external_path_.basename(external_path_.dirname(manifest)),
         hasTests,
+        diagnostics,
     };
 }
 async function fileInfoFromConfig(workspace, output, buildConfig, extraExcludes) {
@@ -12328,7 +12708,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     const actualOptimizedFiles = (await (0,external_util_cjs_namespaceObject.globa)(external_path_.join(output, "**", "*.mc"), { mark: true }))
         .filter((file) => !file.endsWith("/"))
         .sort();
-    const { hasTests, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
+    const { hasTests, diagnostics: prevDiagnostics, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
         .catch(() => "{}"));
     // check that the set of files thats actually there is the same as the
     // set of files we're going to generate (in case eg a jungle file change
@@ -12346,35 +12726,31 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1654222986123 < opt_time) {
-            return hasTests;
+        if (source_time < opt_time && 1654554780017 < opt_time) {
+            return { hasTests, diagnostics: prevDiagnostics };
         }
     }
     await promises_namespaceObject.rm(output, { recursive: true, force: true });
     await promises_namespaceObject.mkdir(output, { recursive: true });
-    await optimizeMonkeyC(fnMap);
+    const diagnostics = await optimizeMonkeyC(fnMap);
     return Promise.all(Object.values(fnMap).map(async (info) => {
         const name = info.output;
         const dir = external_path_.dirname(name);
         await promises_namespaceObject.mkdir(dir, { recursive: true });
         const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(info.ast, info.monkeyCSource);
+        await promises_namespaceObject.writeFile(name, opt_source);
         if (config.checkBuildPragmas) {
-            const matches = opt_source.matchAll(/^.*\/\*\s*@match\s+(\S+)\s+\*\/(.*)$/gm);
-            for (const [line, needle, haystack] of matches) {
-                if (!haystack.includes(needle)) {
-                    throw new Error(`Checking build pragmas in ${name} failed at \n\n${line}\n\n - Didn't find '${needle}'`);
-                }
-            }
+            pragmaChecker(info.ast);
         }
-        await promises_namespaceObject.writeFile(name, opt_source);
         return info.hasTests;
     })).then((results) => {
         const hasTests = results.some((v) => v);
         return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
             hasTests,
+            diagnostics,
             ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
         }))
-            .then(() => hasTests);
+            .then(() => ({ hasTests, diagnostics }));
     });
 }
 async function getProjectAnalysis(targets, analysis, options) {