@markw65/monkeyc-optimizer 1.0.15 → 1.0.18

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,485 @@ 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 getArgSafety(state, func, args, requireAll) {
+    // determine whether decl might be changed by a function call
+    // or assignment during the evaluation of FunctionStateNode.
+    const getSafety = (decl) => {
+        // enums are constant, they cant change
+        if (decl.type === "EnumStringMember")
+            return true;
+        if (decl.type === "VariableDeclarator") {
+            // constants also can't change
+            if (decl.node.kind === "const")
+                return true;
+            // if decl is a local, it also can't be changed
+            // by a call to another function.
+            for (let i = 0;; i++) {
+                if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                    return false;
+                if (state.stack[i].type === "FunctionDeclaration")
+                    return true;
+            }
+        }
+        return null;
+    };
+    const safeArgs = [];
+    let allSafe = true;
+    if (!args.every((arg) => {
+        switch (arg.type) {
+            case "Literal":
+                safeArgs.push(true);
+                return true;
+            case "Identifier":
+            case "MemberExpression": {
+                const [, results] = state.lookup(arg);
+                if (!results || results.length !== 1) {
+                    safeArgs.push(null);
+                    return !requireAll;
+                }
+                const safety = getSafety(results[0]);
+                safeArgs.push(safety);
+                if (!safety) {
+                    allSafe = false;
+                    if (safety === null) {
+                        return !requireAll;
+                    }
+                }
+                return true;
+            }
+        }
+        allSafe = false;
+        safeArgs.push(null);
+        return !requireAll;
+    })) {
+        return false;
+    }
+    if (allSafe && requireAll)
+        return true;
+    let callSeen = false;
+    let ok = true;
+    const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
+    const getLoc = (node) => (Array.isArray(node) ? node[0].start : node.start) || 0;
+    // look for uses of "unsafe" args that occur after a call.
+    // use post to do the checking, because arguments are evaluated
+    // prior to the call, so eg "return f(x.y);" is fine, but
+    // "return f()+x.y" is not.
+    //
+    // We also have to use a "pre" to ensure that child nodes are
+    // visited in source order (otherwise we could visit x.y before f()
+    // in the above example)
+    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+        return Object.entries(node)
+            .filter((kv) => Array.isArray(kv[1])
+            ? kv[1].length !== 0 && (0,external_api_cjs_namespaceObject.hasProperty)(kv[1][0], "type")
+            : (0,external_api_cjs_namespaceObject.hasProperty)(kv[1], "type"))
+            .sort(([, a], [, b]) => getLoc(a) - getLoc(b))
+            .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;
+                break;
+            case "Identifier":
+                if (callSeen &&
+                    (0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
+                    !safeArgs[params[node.name]]) {
+                    safeArgs[params[node.name]] = null;
+                }
+        }
+    });
+    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) {
+        if (node.type === "BinaryExpression" && node.operator === "as") {
+            node = node.left;
+        }
+        else if (node.type === "UnaryExpression" && node.operator === " as") {
+            node = node.argument;
+        }
+        else {
+            break;
+        }
+    }
+    if (node.type === "Literal")
+        return true;
+    if (node.type === "Identifier") {
+        if (func.params.length === 1 &&
+            (0,external_api_cjs_namespaceObject.variableDeclarationName)(func.params[0]) === node.name) {
+            return 1;
+        }
+        return true;
+    }
+    return false;
+}
+var InlineStatus;
+(function (InlineStatus) {
+    InlineStatus[InlineStatus["Never"] = 0] = "Never";
+    InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
+    InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
+})(InlineStatus || (InlineStatus = {}));
+function shouldInline(state, func, args) {
+    let autoInline = false;
+    let inlineAsExpression = false;
+    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 InlineStatus.AsExpression;
+    }
+    const excludeAnnotations = (func.node.loc?.source &&
+        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
+        {};
+    const inlineRequested = 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)))));
+    if (autoInline || inlineRequested) {
+        return inlineAsExpression && canInline(state, func, args)
+            ? InlineStatus.AsExpression
+            : InlineStatus.AsStatement;
+    }
+    return InlineStatus.Never;
+}
+function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
+    if (!params) {
+        const safeArgs = getArgSafety(state, func, call.arguments, false);
+        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];
+        }));
+    }
+    const pre = state.pre;
+    const post = state.post;
+    try {
+        state.pre = (node) => {
+            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!");
+                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 result;
+        };
+        state.post = (node) => {
+            let replacement = null;
+            switch (node.type) {
+                case "Identifier": {
+                    if (state.inType)
+                        break;
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
+                        const ix = params[node.name];
+                        if (ix >= 0) {
+                            replacement = call.arguments[ix];
+                        }
+                        break;
+                    }
+                    replacement = fixNodeScope(state, node, func.stack);
+                    if (!replacement) {
+                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                    }
+                    break;
+                }
+            }
+            return post(replacement || node, state) || replacement;
+        };
+        return state.traverse(root) || null;
+    }
+    catch (ex) {
+        if (ex instanceof Error) {
+            if (ex.message.startsWith("Inliner: ")) {
+                return null;
+            }
+        }
+        throw ex;
+    }
+    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":
+            return unused(expression.object).concat(unused(expression.property));
+    }
+    return top
+        ? null
+        : [
+            {
+                type: "ExpressionStatement",
+                expression,
+            },
+        ];
+}
+function inlineWithArgs(state, func, call) {
+    if (!func.node || !func.node.body) {
+        return null;
+    }
+    let retStmtCount = 0;
+    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+        node.type === "ReturnStatement" && retStmtCount++;
+    });
+    if (retStmtCount > 1 ||
+        (retStmtCount === 1 &&
+            func.node.body.body.slice(-1)[0].type !== "ReturnStatement")) {
+        return null;
+    }
+    const body = JSON.parse(JSON.stringify(func.node.body));
+    processInlineBody(state, func, call, body, func.node.params.length ? false : true);
+    if (retStmtCount) {
+        const last = body.body[body.body.length - 1];
+        if (last.type != "ReturnStatement") {
+            throw new Error("ReturnStatement got lost!");
+        }
+        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, inlineStatus) {
+    if (inlineStatus == InlineStatus.AsStatement) {
+        return inlineWithArgs(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]));
+    return processInlineBody(state, func, call, retArg, true, params) || retArg;
+}
+function applyTypeIfNeeded(node) {
+    if ("enumType" in node && node.enumType) {
+        node = {
+            type: "BinaryExpression",
+            operator: "as",
+            left: node,
+            right: { type: "TypeSpecList", ts: [node.enumType] },
+        };
+    }
+    return node;
+}
+function fixNodeScope(state, lookupNode, nodeStack) {
+    if (lookupNode.type === "Identifier") {
+        for (let i = state.stack.length; --i > nodeStack.length;) {
+            const si = state.stack[i];
+            if ((0,external_api_cjs_namespaceObject.hasProperty)(si.decls, lookupNode.name)) {
+                // its a local from the inlined function.
+                // Nothing to do.
+                return lookupNode;
+            }
+        }
+    }
+    const [, original] = state.lookup(lookupNode, null, nodeStack);
+    if (!original) {
+        return null;
+    }
+    const [, current] = state.lookup(lookupNode);
+    // For now, leave it alone if it already maps to the same thing.
+    // With a bit more work, we could find the guaranteed shortest
+    // reference, and then use this to optimize *all* symbols, not
+    // just fix inlined ones.
+    if (current &&
+        current.length === original.length &&
+        current.every((item, index) => item == original[index])) {
+        return lookupNode;
+    }
+    const node = lookupNode.type === "Identifier"
+        ? lookupNode
+        : lookupNode.property;
+    if (original.length === 1 && original[0].type === "EnumStringMember") {
+        return applyTypeIfNeeded(original[0].init);
+    }
+    const prefixes = original.map((sn) => {
+        if ((0,external_api_cjs_namespaceObject.isStateNode)(sn) && sn.fullName) {
+            return sn.fullName;
+        }
+        return "";
+    });
+    if (prefixes.length &&
+        prefixes[0].startsWith("$.") &&
+        prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
+        const prefix = prefixes[0].split(".").slice(0, -1).reverse();
+        let found = false;
+        return prefix.reduce((current, name) => {
+            if (found)
+                return current;
+            const [, results] = state.lookup(current);
+            if (results &&
+                results.length === original.length &&
+                results.every((result, i) => result === original[i])) {
+                found = true;
+                return current;
+            }
+            const object = typeof name === "string"
+                ? {
+                    type: "Identifier",
+                    name,
+                    start: node.start,
+                    end: node.end,
+                    loc: node.loc,
+                }
+                : name;
+            let root = null;
+            let property = current;
+            while (property.type !== "Identifier") {
+                root = property;
+                property = property.object;
+            }
+            const mb = {
+                type: "MemberExpression",
+                object,
+                property,
+                computed: false,
+                start: node.start,
+                end: node.end,
+                loc: node.loc,
+            };
+            if (root) {
+                root.object = mb;
+            }
+            else {
+                current = mb;
+            }
+            return current;
+        }, node);
+    }
+    return null;
+}
+
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
 
 
+
+
 function processImports(allImports, lookup) {
     allImports.forEach(({ node, stack }) => {
         const [name, module] = lookup(node.id, ("as" in node && node.as && node.as.name) || null, stack);
@@ -10809,10 +11283,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] = [];
@@ -10914,30 +11391,34 @@ function getFileASTs(fnMap) {
     }, true));
 }
 async function analyze(fnMap) {
-    let excludeAnnotations;
     let hasTests = false;
     const allImports = [];
     const preState = {
+        fnMap,
         allFunctions: [],
         allClasses: [],
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
                 "attrs" in node.attrs &&
-                node.attrs.attrs) {
-                return node.attrs.attrs.reduce((drop, attr) => {
-                    if (attr.type != "UnaryExpression")
-                        return drop;
-                    if (attr.argument.type != "Identifier")
+                node.attrs.attrs &&
+                node.loc?.source) {
+                const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
+                if (excludeAnnotations) {
+                    return node.attrs.attrs.reduce((drop, attr) => {
+                        if (attr.type != "UnaryExpression")
+                            return drop;
+                        if (attr.argument.type != "Identifier")
+                            return drop;
+                        if ((0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name)) {
+                            return true;
+                        }
+                        if (attr.argument.name == "test") {
+                            hasTests = true;
+                        }
                         return drop;
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name)) {
-                        return true;
-                    }
-                    if (attr.argument.name == "test") {
-                        hasTests = true;
-                    }
-                    return drop;
-                }, false);
+                    }, false);
+                }
             }
             return false;
         },
@@ -10986,7 +11467,6 @@ async function analyze(fnMap) {
         if (!ast) {
             throw parserError || new Error(`Failed to parse ${name}`);
         }
-        excludeAnnotations = value.excludeAnnotations;
         hasTests = false;
         (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
         value.hasTests = hasTests;
@@ -11010,8 +11490,8 @@ function getLiteralFromDecls(decls) {
     let result = null;
     if (decls.every((d) => {
         if (d.type === "EnumStringMember" ||
-            (d.type === "VariableDeclarator" && d.kind === "const")) {
-            const init = getLiteralNode(d.init);
+            (d.type === "VariableDeclarator" && d.node.kind === "const")) {
+            const init = getLiteralNode(d.type === "EnumStringMember" ? d.init : d.node.init);
             if (!init)
                 return false;
             if (!result) {
@@ -11350,57 +11830,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;
                         }
@@ -11424,7 +11855,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": {
@@ -11442,7 +11873,7 @@ async function optimizeMonkeyC(fnMap) {
                         state.exposed[node.name] = true;
                     }
                 }
-                return false;
+                return [];
             }
             case "MemberExpression":
                 if (node.property.type === "Identifier" && !node.computed) {
@@ -11524,49 +11955,37 @@ async function optimizeMonkeyC(fnMap) {
                 }
                 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, false);
+                if (ret) {
+                    replace(node, ret);
                 }
-                if (callees.length == 1) {
-                    const callee = (0,external_api_cjs_namespaceObject.isStateNode)(callees[0]) && callees[0].node;
-                    if (callee &&
-                        callee.type == "FunctionDeclaration" &&
-                        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 "ExpressionStatement":
+                if (node.expression.type === "CallExpression") {
+                    const ret = optimizeCall(state, node.expression, true);
+                    if (ret) {
+                        if (ret.type === "BlockStatement") {
+                            return ret;
                         }
+                        node.expression = 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;
     };
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
+    delete state.pre;
+    delete state.post;
     const cleanup = (node) => {
         switch (node.type) {
             case "EnumStringBody":
@@ -11641,6 +12060,98 @@ async function optimizeMonkeyC(fnMap) {
         });
     });
 }
+function optimizeCall(state, node, asStatement) {
+    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 (callee.optimizable &&
+            !callee.hasOverride &&
+            node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
+            const ret = evaluateFunction(callee, node.arguments);
+            if (ret) {
+                return ret;
+            }
+        }
+        const inlineStatus = shouldInline(state, callees[0], node.arguments);
+        if (inlineStatus === InlineStatus.AsExpression ||
+            (asStatement && inlineStatus === InlineStatus.AsStatement)) {
+            const ret = inlineFunction(state, callees[0], node, inlineStatus);
+            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) && state.calledFunctions[name].push(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;
+    const next = () => {
+        while (++index < comments.length) {
+            comment = comments[index];
+            if (comment.value.match(/^\s*@match\s+/)) {
+                break;
+            }
+        }
+    };
+    next();
+    (0,external_api_cjs_namespaceObject.traverseAst)(ast, (node) => {
+        if (index >= comments.length)
+            return false;
+        if (node.start && node.start >= (comment.end || Infinity)) {
+            let match = comment.value.match(/^\s*@match\s+([/%&#@"])(.+(?<!\\)(?:\\{2})*)\1\s+$/) || comment.value.match(/^\s*@match\s+(\S+)\s+$/);
+            if (!match) {
+                throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
+            }
+            const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/[\r\n]/g, " ");
+            let found = false;
+            let needle = match[1];
+            if (match.length == 2) {
+                found = haystack.includes(needle);
+            }
+            else {
+                if (needle == '"') {
+                    found = haystack.includes((needle = match[2]));
+                }
+                else {
+                    const re = new RegExp((needle = match[2]));
+                    found = re.test(haystack);
+                }
+            }
+            if (!found) {
+                throw new Error(`Didn't find '${needle}' in ${comment.loc.source}:${comment.loc.start.line}`);
+            }
+            next();
+        }
+        return null;
+    });
+}
 
 ;// CONCATENATED MODULE: ./src/optimizer.ts
 
@@ -11656,6 +12167,7 @@ async function optimizeMonkeyC(fnMap) {
 
 
 
+
 function relative_path_no_dotdot(relative) {
     return relative.replace(/^(\.\.[\\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
 }
@@ -12054,6 +12566,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     // might have altered it), and that the options we care about haven't
     // changed
     if (hasTests != null &&
+        !config.checkBuildPragmas &&
         configOptionsToCheck.every((option) => prevOptions[option] === config[option]) &&
         actualOptimizedFiles.length == Object.values(fnMap).length &&
         Object.values(fnMap)
@@ -12064,7 +12577,7 @@ 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 && 1653954367574 < opt_time) {
+        if (source_time < opt_time && 1654389404778 < opt_time) {
             return hasTests;
         }
     }
@@ -12077,6 +12590,9 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         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) {
+            pragmaChecker(info.ast);
+        }
         return info.hasTests;
     })).then((results) => {
         const hasTests = results.some((v) => v);
@@ -12133,11 +12649,12 @@ async function generateApiMirTests(options) {
                     return;
                 const d = decl[0];
                 if (d.type === "EnumStringMember" ||
-                    (d.type === "VariableDeclarator" && d.kind === "const")) {
-                    if (!d.init) {
+                    (d.type === "VariableDeclarator" && d.node.kind === "const")) {
+                    const init = (0,external_api_cjs_namespaceObject.isStateNode)(d) ? d.node.init : d.init;
+                    if (!init) {
                         throw new Error(`Missing init for ${node.fullName}.${key}`);
                     }
-                    tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(d.init)]);
+                    tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(init)]);
                 }
                 else if ((0,external_api_cjs_namespaceObject.isStateNode)(d)) {
                     findConstants(d);