@markw65/monkeyc-optimizer 1.0.15 → 1.0.16

package/README.md

@@ -161,3 +161,20 @@ More fixes found via open source projects.
 - Bug fixes
   - Inject the superclass name into the classes namespace
   - Separate type vs value lookup, and use the correct one based on context.
+
+### 1.0.16
+
+- Bug fixes
+
+  - Fix off-by-one in removeNodeComments
+  - Fix lookup to consistently lookup types or values.
+  - Fix lookup of superclass names
+
+- New Features
+
+  - Add a simple inliner
+  - Add support for conditional inlining based on excludeAnnotations
+
+- Testing
+  - Add support for @match pragmas to check the optimization results
+  - Add a test project, with some inlining tests

package/build/api.cjs

@@ -233,6 +233,276 @@ const promises_namespaceObject = require("fs/promises");
 var standalone = __webpack_require__(3945);
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
+;// CONCATENATED MODULE: ./src/inliner.ts
+
+function canInline(state, func, args) {
+    // determine whether decl might be changed by a function call
+    // 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)
+                    return false;
+                const safety = getSafety(results[0]);
+                if (safety === null)
+                    return false;
+                if (!safety)
+                    allSafe = false;
+                safeArgs.push(safety);
+                return true;
+            }
+        }
+        return false;
+    })) {
+        return false;
+    }
+    if (allSafe)
+        return true;
+    let callSeen = false;
+    let ok = true;
+    const params = Object.fromEntries(func.node.params.map((param, i) => [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)
+    traverseAst(func.node.body, (node) => {
+        return Object.entries(node)
+            .filter((kv) => Array.isArray(kv[1])
+            ? kv[1].length !== 0 && hasProperty(kv[1][0], "type")
+            : hasProperty(kv[1], "type"))
+            .sort(([, a], [, b]) => getLoc(a) - getLoc(b))
+            .map(([key]) => key);
+    }, (node) => {
+        switch (node.type) {
+            case "CallExpression":
+            case "NewExpression":
+                callSeen = true;
+                break;
+            case "Identifier":
+                if (callSeen &&
+                    hasProperty(params, node.name) &&
+                    !safeArgs[params[node.name]]) {
+                    ok = false;
+                }
+        }
+    });
+    return ok;
+}
+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 &&
+            variableDeclarationName(func.params[0]) === node.name) {
+            return 1;
+        }
+        return true;
+    }
+    return false;
+}
+function inliner_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);
+    const excludeAnnotations = (func.node.loc?.source &&
+        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_") &&
+                        hasProperty(excludeAnnotations, attr.argument.name.substring(7))))))) &&
+        (autoInline === 1 || canInline(state, func, args)));
+}
+function inliner_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) => [variableDeclarationName(param), i]));
+    try {
+        const result = 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 [];
+                    }
+            }
+            return null;
+        }, (node) => {
+            switch (node.type) {
+                case "Identifier": {
+                    if (hasProperty(params, node.name)) {
+                        return call.arguments[params[node.name]];
+                    }
+                    const rep = fixNodeScope(state, node, func.stack);
+                    if (!rep) {
+                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                    }
+                    return rep;
+                }
+            }
+            return null;
+        }) || retArg;
+        result.loc = call.loc;
+        result.start = call.start;
+        result.end = call.end;
+        return result;
+    }
+    catch (ex) {
+        if (ex instanceof Error) {
+            if (ex.message.startsWith("Inliner: ")) {
+                return null;
+            }
+        }
+        throw ex;
+    }
+}
+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) {
+    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 (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: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
@@ -240,6 +510,7 @@ const external_util_cjs_namespaceObject = require("./util.cjs");
 
 
 
+
 function processImports(allImports, lookup) {
     allImports.forEach(({ node, stack }) => {
         const [name, module] = lookup(node.id, ("as" in node && node.as && node.as.name) || null, stack);
@@ -359,30 +630,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 (hasProperty(excludeAnnotations, attr.argument.name)) {
+                            return true;
+                        }
+                        if (attr.argument.name == "test") {
+                            hasTests = true;
+                        }
                         return drop;
-                    if (hasProperty(excludeAnnotations, attr.argument.name)) {
-                        return true;
-                    }
-                    if (attr.argument.name == "test") {
-                        hasTests = true;
-                    }
-                    return drop;
-                }, false);
+                    }, false);
+                }
             }
             return false;
         },
@@ -431,7 +706,6 @@ async function analyze(fnMap) {
         if (!ast) {
             throw parserError || new Error(`Failed to parse ${name}`);
         }
-        excludeAnnotations = value.excludeAnnotations;
         hasTests = false;
         collectNamespaces(ast, state);
         value.hasTests = hasTests;
@@ -455,8 +729,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) {
@@ -986,11 +1260,9 @@ async function optimizeMonkeyC(fnMap) {
                     }
                     return null;
                 }
-                if (callees.length == 1) {
-                    const callee = isStateNode(callees[0]) && callees[0].node;
-                    if (callee &&
-                        callee.type == "FunctionDeclaration" &&
-                        callee.optimizable &&
+                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);
@@ -999,6 +1271,13 @@ async function optimizeMonkeyC(fnMap) {
                             return null;
                         }
                     }
+                    if (shouldInline(state, callees[0], node.arguments)) {
+                        const ret = inlineFunction(state, callees[0], node);
+                        if (ret) {
+                            replace(node, ret);
+                            return null;
+                        }
+                    }
                 }
                 if (!hasProperty(state.calledFunctions, name)) {
                     state.calledFunctions[name] = [];
@@ -1012,6 +1291,8 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         collectNamespaces(f.ast, state);
     });
+    delete state.pre;
+    delete state.post;
     const cleanup = (node) => {
         switch (node.type) {
             case "EnumStringBody":
@@ -1178,13 +1459,14 @@ async function api_getApiMapping(state) {
             filepath: "api.mir",
         }), state);
         negativeFixups.forEach((fixup) => {
-            const value = fixup.split(".").reduce((state, part) => {
+            const vs = fixup.split(".").reduce((state, part) => {
                 const decls = api_isStateNode(state) && state.decls?.[part];
                 if (!Array.isArray(decls) || decls.length != 1 || !decls[0]) {
                     throw `Failed to find and fix negative constant ${fixup}`;
                 }
                 return decls[0];
             }, result);
+            const value = api_isStateNode(vs) ? vs.node : vs;
             if (value.type !== "EnumStringMember" &&
                 (value.type !== "VariableDeclarator" || value.kind != "const")) {
                 throw `Negative constant ${fixup} did not refer to a constant`;
@@ -1221,8 +1503,19 @@ function api_variableDeclarationName(node) {
     return ("left" in node ? node.left : node).name;
 }
 function checkOne(ns, decls, name) {
-    if (api_isStateNode(ns) && api_hasProperty(ns[decls], name)) {
-        return ns[decls][name];
+    if (api_isStateNode(ns)) {
+        if (api_hasProperty(ns[decls], name)) {
+            return ns[decls][name];
+        }
+        if (ns.type == "ClassDeclaration" &&
+            ns.superClass &&
+            ns.superClass !== true) {
+            const found = ns.superClass
+                .map((cls) => checkOne(cls, decls, name))
+                .filter((n) => n != null)
+                .flat(1);
+            return found.length ? found : null;
+        }
     }
     return null;
 }
@@ -1232,7 +1525,7 @@ function lookup(state, decls, node, name, stack) {
         case "MemberExpression": {
             if (node.property.type != "Identifier" || node.computed)
                 break;
-            const [, module, where] = state.lookup(node.object, name, stack);
+            const [, module, where] = lookup(state, decls, node.object, name, stack);
             if (module && module.length === 1) {
                 const result = checkOne(module[0], decls, node.property.name);
                 if (result) {
@@ -1283,22 +1576,18 @@ function api_collectNamespaces(ast, stateIn) {
     state.removeNodeComments = (node, ast) => {
         if (node.start && node.end && ast.comments && ast.comments.length) {
             let low = 0, high = ast.comments.length;
-            while (true) {
+            while (high > low) {
                 const mid = (low + high) >> 1;
-                if (mid == low) {
-                    if (ast.comments[mid].start < node.start) {
-                        return;
-                    }
-                    break;
-                }
                 if (ast.comments[mid].start < node.start) {
-                    low = mid;
+                    low = mid + 1;
                 }
                 else {
                     high = mid;
                 }
             }
-            for (high = low; high < ast.comments.length && ast.comments[high].end < node.end; high++) { }
+            while (high < ast.comments.length && ast.comments[high].end < node.end) {
+                high++;
+            }
             if (high > low) {
                 ast.comments.splice(low, high - low);
             }
@@ -1401,7 +1690,17 @@ function api_collectNamespaces(ast, stateIn) {
                     if (!api_hasProperty(parent.type_decls, name)) {
                         parent.type_decls[name] = [];
                     }
-                    (0,external_util_cjs_namespaceObject.pushUnique)(parent.type_decls[name], node);
+                    else if (parent.type_decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == node)) {
+                        break;
+                    }
+                    parent.type_decls[name].push(node.type === "EnumDeclaration"
+                        ? node
+                        : {
+                            type: "TypedefDeclaration",
+                            node,
+                            name,
+                            fullName: parent.fullName + "." + name,
+                        });
                     break;
                 }
                 case "VariableDeclaration": {
@@ -1409,13 +1708,23 @@ function api_collectNamespaces(ast, stateIn) {
                     if (!parent.decls)
                         parent.decls = {};
                     const decls = parent.decls;
+                    const stack = state.stack.slice();
                     node.declarations.forEach((decl) => {
                         const name = api_variableDeclarationName(decl.id);
                         if (!api_hasProperty(decls, name)) {
                             decls[name] = [];
                         }
+                        else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
+                            return;
+                        }
                         decl.kind = node.kind;
-                        (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], decl);
+                        (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], {
+                            type: "VariableDeclarator",
+                            node: decl,
+                            name,
+                            fullName: parent.fullName + "." + name,
+                            stack,
+                        });
                         if (node.kind == "const") {
                             if (!api_hasProperty(state.index, name)) {
                                 state.index[name] = [];

package/build/optimizer.cjs

@@ -10791,11 +10791,282 @@ 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/inliner.ts
+
+function canInline(state, func, args) {
+    // determine whether decl might be changed by a function call
+    // 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)
+                    return false;
+                const safety = getSafety(results[0]);
+                if (safety === null)
+                    return false;
+                if (!safety)
+                    allSafe = false;
+                safeArgs.push(safety);
+                return true;
+            }
+        }
+        return false;
+    })) {
+        return false;
+    }
+    if (allSafe)
+        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 "CallExpression":
+            case "NewExpression":
+                callSeen = true;
+                break;
+            case "Identifier":
+                if (callSeen &&
+                    (0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
+                    !safeArgs[params[node.name]]) {
+                    ok = false;
+                }
+        }
+    });
+    return ok;
+}
+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;
+}
+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);
+    const excludeAnnotations = (func.node.loc?.source &&
+        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]));
+    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 [];
+                    }
+            }
+            return null;
+        }, (node) => {
+            switch (node.type) {
+                case "Identifier": {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
+                        return call.arguments[params[node.name]];
+                    }
+                    const rep = fixNodeScope(state, node, func.stack);
+                    if (!rep) {
+                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                    }
+                    return rep;
+                }
+            }
+            return null;
+        }) || retArg;
+        result.loc = call.loc;
+        result.start = call.start;
+        result.end = call.end;
+        return result;
+    }
+    catch (ex) {
+        if (ex instanceof Error) {
+            if (ex.message.startsWith("Inliner: ")) {
+                return null;
+            }
+        }
+        throw ex;
+    }
+}
+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) {
+    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);
@@ -10914,30 +11185,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 +11261,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 +11284,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) {
@@ -11541,11 +11815,9 @@ async function optimizeMonkeyC(fnMap) {
                     }
                     return null;
                 }
-                if (callees.length == 1) {
-                    const callee = (0,external_api_cjs_namespaceObject.isStateNode)(callees[0]) && callees[0].node;
-                    if (callee &&
-                        callee.type == "FunctionDeclaration" &&
-                        callee.optimizable &&
+                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);
@@ -11554,6 +11826,13 @@ async function optimizeMonkeyC(fnMap) {
                             return null;
                         }
                     }
+                    if (shouldInline(state, callees[0], node.arguments)) {
+                        const ret = inlineFunction(state, callees[0], node);
+                        if (ret) {
+                            replace(node, ret);
+                            return null;
+                        }
+                    }
                 }
                 if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
                     state.calledFunctions[name] = [];
@@ -11567,6 +11846,8 @@ async function optimizeMonkeyC(fnMap) {
     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":
@@ -12054,6 +12335,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 +12346,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 && 1654222986123 < opt_time) {
             return hasTests;
         }
     }
@@ -12076,6 +12358,14 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         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);
+        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}'`);
+                }
+            }
+        }
         await promises_namespaceObject.writeFile(name, opt_source);
         return info.hasTests;
     })).then((results) => {
@@ -12133,11 +12423,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);

package/build/src/inliner.d.ts

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, args: mctree.Node[]): boolean | undefined;
+export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression): any;
+export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;

package/build/src/optimizer.d.ts

@@ -34,12 +34,13 @@ declare global {
         ignoredAnnotations?: string;
         ignoredSourcePaths?: string;
         returnCommand?: boolean;
+        checkBuildPragmas?: boolean;
         _cache?: {
             barrels?: Record<string, ResolvedJungle>;
             barrelMap?: Record<string, Record<string, ResolvedJungle>>;
         };
     };
-    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration | mctree.TypedefDeclaration | mctree.VariableDeclarator;
+    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
     type StateNodeDecls = {
         [key: string]: StateNodeDecl[];
     };
@@ -87,11 +88,25 @@ declare global {
         node: mctree.BlockStatement;
         stack?: undefined;
     }
-    type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode;
+    interface TypedefStateNode extends BaseStateNode {
+        type: "TypedefDeclaration";
+        node: mctree.TypedefDeclaration;
+        name: string;
+        fullName: string;
+    }
+    interface VariableStateNode extends BaseStateNode {
+        type: "VariableDeclarator";
+        node: mctree.VariableDeclarator;
+        name: string;
+        fullName: string;
+        stack: ProgramStateStack;
+    }
+    type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode;
     type ProgramStateStack = StateNode[];
     export type ProgramState = {
         allFunctions?: FunctionStateNode[];
         allClasses?: ClassStateNode[];
+        fnMap?: FilesToOptimizeMap;
         stack?: ProgramStateStack;
         removeNodeComments?: (node: mctree.Node, ast: mctree.Program) => void;
         shouldExclude?: (node: mctree.Node) => boolean;
@@ -128,7 +143,7 @@ declare global {
         [key in Keys]-?: NonNullable<T[key]>;
     };
     export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType">;
-    export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions">;
+    export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap">;
     export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions">;
     type ExcludeAnnotationsMap = {
         [key: string]: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -20,8 +20,9 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-remote",
-    "test-remote": "node ./test/test.js --product=pick-one --github"
+    "test": "npm run test-inline && npm run test-remote",
+    "test-remote": "node ./test/test.js --product=pick-one --github",
+    "test-inline": "node test/test.js --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle"
   },
   "files": [
     "build/optimizer.cjs",