@markw65/monkeyc-optimizer 1.0.22 → 1.0.23

package/README.md

@@ -263,4 +263,15 @@ More fixes found via open source projects.
   - Recognize the the variable in a catch clause is a declaration
 
 - Breaking change
-  - By popular demand, reversed the sense of inline_foo, so now it inlines when foo is _not_ declared as an excludeAnnotation
+  - By popular demand, reversed the sense of `inline*foo`, so now it inlines when foo is _not_ declared as an excludeAnnotation
+
+### 1.0.23
+
+- Bug Fixes
+
+  - Don't treat parameters to Method types as undeclared variables
+    - eg `var x as (Method(a as Number, b as Number) as Void)` should not report that `a` and `b` are undeclared
+
+- Tests
+  - Various new tests for module/class/local resolution of symbols
+  - Make tests fail by default if the optimizer reports any undefined symbols, and add `@expects` or `checkInvalidSymbols=WARNING` as needed to prevent test failures.

package/build/api.cjs

@@ -59,7 +59,7 @@ __webpack_require__.d(__webpack_exports__, {
   "hasProperty": () => (/* binding */ api_hasProperty),
   "isStateNode": () => (/* binding */ api_isStateNode),
   "sameLookupResult": () => (/* binding */ api_sameLookupResult),
-  "traverseAst": () => (/* binding */ api_traverseAst),
+  "traverseAst": () => (/* reexport */ ast_traverseAst),
   "variableDeclarationName": () => (/* binding */ api_variableDeclarationName),
   "visitReferences": () => (/* reexport */ visitor_visitReferences)
 });
@@ -71,10 +71,148 @@ var prettier_plugin_monkeyc_default = /*#__PURE__*/__webpack_require__.n(prettie
 const promises_namespaceObject = require("fs/promises");
 ;// CONCATENATED MODULE: external "prettier"
 const external_prettier_namespaceObject = require("prettier");
+;// CONCATENATED MODULE: ./src/ast.ts
+/*
+ * This ensures that mctreeTypeInfo has every key of MCTreeTypeInfo,
+ * and that the corresponding arrays contain every element of the
+ * corresponding type.
+ *
+ * ie, any time mctree.Node changes, we'll get errors here if
+ * mctreeTypeInfo needs updating.
+ *
+ */
+function _check(x) {
+    const y = x;
+    x = y;
+}
+const mctreeTypeInfo = {
+    ArrayExpression: ["elements"],
+    AssignmentExpression: ["left", "right"],
+    AttributeList: ["attributes"],
+    Attributes: ["elements"],
+    BinaryExpression: ["left", "right"],
+    Block: [],
+    BlockStatement: ["body", "innerComments"],
+    BreakStatement: [],
+    CallExpression: ["callee", "arguments"],
+    CatchClause: ["param", "body"],
+    CatchClauses: ["catches"],
+    ClassBody: ["body"],
+    ClassDeclaration: ["attrs", "id", "superClass", "body"],
+    ClassElement: ["item"],
+    ConditionalExpression: ["test", "consequent", "alternate"],
+    ContinueStatement: [],
+    DoWhileStatement: ["body", "test"],
+    EnumDeclaration: ["attrs", "id", "body"],
+    EnumStringBody: ["members"],
+    EnumStringMember: ["id", "init"],
+    ExpressionStatement: ["expression"],
+    ForStatement: ["init", "test", "body", "update"],
+    FunctionDeclaration: ["attrs", "id", "params", "body"],
+    Identifier: [],
+    IfStatement: ["test", "consequent", "alternate"],
+    ImportModule: ["id"],
+    InstanceOfCase: ["id"],
+    Line: [],
+    Literal: [],
+    LogicalExpression: ["left", "right"],
+    MemberExpression: ["object", "property"],
+    MethodDefinition: ["params", "returnType"],
+    ModuleDeclaration: ["attrs", "id", "body"],
+    MultiLine: [],
+    NewExpression: ["callee", "arguments"],
+    ObjectExpression: ["properties"],
+    ParenthesizedExpression: ["expression"],
+    Program: ["body", "comments"],
+    Property: ["key", "value"],
+    ReturnStatement: ["argument"],
+    SequenceExpression: ["expressions"],
+    SizedArrayExpression: ["size", "ts"],
+    SwitchCase: ["test", "consequent"],
+    SwitchStatement: ["discriminant", "cases"],
+    ThisExpression: [],
+    ThrowStatement: ["argument"],
+    TryStatement: ["block", "handler", "finalizer"],
+    TypedefDeclaration: ["attrs", "id", "ts"],
+    TypeSpecList: ["ts"],
+    TypeSpecPart: ["body", "callspec", "generics"],
+    UnaryExpression: ["argument"],
+    UpdateExpression: ["argument"],
+    Using: ["id", "as"],
+    VariableDeclaration: ["attrs", "declarations"],
+    VariableDeclarator: ["id", "init"],
+    WhileStatement: ["test", "body"],
+};
+function isMCTreeNode(node) {
+    return node ? typeof node === "object" && "type" in node : false;
+}
+/*
+ * Traverse the ast rooted at node, calling pre before
+ * visiting each node, and post after.
+ *
+ *  - if pre returns false, the node is not traversed, and
+ *    post is not called;
+ *  - if pre returns a list of child nodes, only those will
+ *    be traversed
+ *  - otherwise all child nodes are traversed
+ *
+ *  - if post returns false, the node it was called on is
+ *    removed.
+ */
+function ast_traverseAst(node, pre, post) {
+    const nodes = pre && pre(node);
+    if (nodes === false)
+        return;
+    if (!mctreeTypeInfo[node.type]) {
+        throw new Error("what?");
+    }
+    for (const key of nodes || mctreeTypeInfo[node.type]) {
+        const value = node[key];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            const values = value;
+            const deletions = values.reduce((state, obj, i) => {
+                if (isMCTreeNode(obj)) {
+                    const repl = ast_traverseAst(obj, pre, post);
+                    if (repl === false) {
+                        if (!state)
+                            state = {};
+                        state[i] = true;
+                    }
+                    else if (repl != null) {
+                        if (!state)
+                            state = {};
+                        values[i] = repl;
+                    }
+                }
+                return state;
+            }, null);
+            if (deletions) {
+                values.splice(0, values.length, ...values.filter((obj, i) => deletions[i] !== true).flat(1));
+            }
+        }
+        else if (isMCTreeNode(value)) {
+            const repl = ast_traverseAst(value, pre, post);
+            if (repl === false) {
+                delete node[key];
+            }
+            else if (repl != null) {
+                if (Array.isArray(repl)) {
+                    throw new Error("Array returned by traverseAst in Node context");
+                }
+                node[key] = repl;
+            }
+        }
+    }
+    return post && post(node);
+}
+
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
+
 function variable_renamer_renameVariable(state, locals, declName) {
     const map = locals.map;
     if (!hasProperty(map, declName))
@@ -131,6 +269,7 @@ function variable_renamer_renameVariable(state, locals, declName) {
 ;// 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.
@@ -198,25 +337,12 @@ function getArgSafety(state, func, args, requireAll) {
     if (allSafe && requireAll)
         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) => {
+    traverseAst(func.node.body, null, (node) => {
         switch (node.type) {
             case "AssignmentExpression":
             case "UpdateExpression": {
@@ -726,6 +852,20 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
                     return ["object"];
                 }
                 break;
+            case "MethodDefinition": {
+                if (!state.inType) {
+                    throw new Error("Method definition outside of type!");
+                }
+                if (node.params) {
+                    node.params.forEach((param) => {
+                        if (param.type == "BinaryExpression") {
+                            state.traverse(param.right);
+                            state.inType = true;
+                        }
+                    });
+                }
+                return ["returnType"];
+            }
         }
         return null;
     };
@@ -741,6 +881,7 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
 
 
 
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -822,7 +963,9 @@ function getFileSources(fnMap) {
             fs
                 .readFile(name)
                 .then((data) => (value.monkeyCSource = data.toString().replace(/\r\n/g, "\n"))));
-    })).then(() => { });
+    })).then(() => {
+        return;
+    });
 }
 function getFileASTs(fnMap) {
     return getFileSources(fnMap).then(() => Object.entries(fnMap).reduce((ok, [name, value]) => {
@@ -885,6 +1028,7 @@ async function analyze(fnMap, barrelList, config) {
                         node.body = null;
                         break;
                     }
+                // falls through
                 case "ModuleDeclaration":
                 case "ClassDeclaration": {
                     const [scope] = state.stack.slice(-1);
@@ -928,7 +1072,7 @@ async function analyze(fnMap, barrelList, config) {
     if (diagnosticType &&
         !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
         const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
-        Object.entries(fnMap).forEach(([k, v]) => {
+        Object.entries(fnMap).forEach(([, v]) => {
             visitReferences(state, v.ast, null, false, (node, results, error) => {
                 if (!error)
                     return undefined;
@@ -1273,7 +1417,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             case "ConditionalExpression":
             case "IfStatement":
             case "DoWhileStatement":
-            case "WhileStatement":
+            case "WhileStatement": {
                 const test = (state.traverse(node.test) ||
                     node.test);
                 const [value, type] = getNodeValue(test);
@@ -1305,6 +1449,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     }
                 }
                 return null;
+            }
             case "EnumDeclaration":
                 return false;
             case "ForStatement": {
@@ -1739,6 +1884,8 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
 
 
 
+
+
 /*
  * This is an unfortunate hack. I want to be able to extract things
  * like the types of all of a Class's variables (in particular the type
@@ -1786,8 +1933,9 @@ async function api_getApiMapping(state, barrelList) {
                 return decls[0];
             }, result);
             const value = api_isStateNode(vs) ? vs.node : vs;
-            if (value.type !== "EnumStringMember" &&
-                (value.type !== "VariableDeclarator" || value.kind != "const")) {
+            if (!value ||
+                (value.type !== "EnumStringMember" &&
+                    (value.type !== "VariableDeclarator" || value.kind != "const"))) {
                 throw `Negative constant ${fixup} did not refer to a constant`;
             }
             const init = getLiteralNode(value.init);
@@ -1835,8 +1983,9 @@ function checkOne(state, ns, decls, node, isStatic) {
             return null;
         }
         return cls.superClass.reduce((result, sup) => {
-            const next = api_hasProperty(sup[decls], node.name)
-                ? sup[decls][node.name]
+            const sdecls = sup[decls];
+            const next = api_hasProperty(sdecls, node.name)
+                ? sdecls[node.name]
                 : superChain(sup);
             return next ? (result ? result.concat(next) : next) : result;
         }, null);
@@ -1859,8 +2008,9 @@ function checkOne(state, ns, decls, node, isStatic) {
         }, null);
     };
     if (api_isStateNode(ns)) {
-        if (api_hasProperty(ns[decls], node.name)) {
-            return ns[decls][node.name];
+        const ndecls = ns[decls];
+        if (api_hasProperty(ndecls, node.name)) {
+            return ndecls[node.name];
         }
         switch (ns.type) {
             case "ClassDeclaration":
@@ -2025,14 +2175,15 @@ function api_collectNamespaces(ast, stateIn) {
             let low = 0, high = ast.comments.length;
             while (high > low) {
                 const mid = (low + high) >> 1;
-                if (ast.comments[mid].start < node.start) {
+                if ((ast.comments[mid].start || 0) < node.start) {
                     low = mid + 1;
                 }
                 else {
                     high = mid;
                 }
             }
-            while (high < ast.comments.length && ast.comments[high].end < node.end) {
+            while (high < ast.comments.length &&
+                (ast.comments[high].end || 0) < node.end) {
                 high++;
             }
             if (high > low) {
@@ -2048,7 +2199,7 @@ function api_collectNamespaces(ast, stateIn) {
         ? { ...elm }
         : elm);
     state.inType = false;
-    state.traverse = (root) => api_traverseAst(root, (node) => {
+    state.traverse = (root) => ast_traverseAst(root, (node) => {
         try {
             if (state.shouldExclude && state.shouldExclude(node)) {
                 // don't visit any children, but do call post
@@ -2340,67 +2491,6 @@ function api_collectNamespaces(ast, stateIn) {
     }
     return state.stack[0];
 }
-function isMCTreeNode(node) {
-    return node ? typeof node === "object" && "type" in node : false;
-}
-/*
- * Traverse the ast rooted at node, calling pre before
- * visiting each node, and post after.
- *
- *  - if pre returns false, the node is not traversed, and
- *    post is not called;
- *  - if pre returns a list of child nodes, only those will
- *    be traversed
- *  - otherwise all child nodes are traversed
- *
- *  - if post returns false, the node it was called on is
- *    removed.
- */
-function api_traverseAst(node, pre, post) {
-    const nodes = pre && pre(node);
-    if (nodes === false)
-        return;
-    for (const key of nodes || Object.keys(node)) {
-        const value = node[key];
-        if (!value)
-            continue;
-        if (Array.isArray(value)) {
-            const values = value;
-            const deletions = values.reduce((state, obj, i) => {
-                if (isMCTreeNode(obj)) {
-                    const repl = api_traverseAst(obj, pre, post);
-                    if (repl === false) {
-                        if (!state)
-                            state = {};
-                        state[i] = true;
-                    }
-                    else if (repl != null) {
-                        if (!state)
-                            state = {};
-                        values[i] = repl;
-                    }
-                }
-                return state;
-            }, null);
-            if (deletions) {
-                values.splice(0, values.length, ...values.filter((obj, i) => deletions[i] !== true).flat(1));
-            }
-        }
-        else if (isMCTreeNode(value)) {
-            const repl = api_traverseAst(value, pre, post);
-            if (repl === false) {
-                delete node[key];
-            }
-            else if (repl != null) {
-                if (Array.isArray(repl)) {
-                    throw new Error("Array returned by traverseAst in Node context");
-                }
-                node[key] = repl;
-            }
-        }
-    }
-    return post && post(node);
-}
 function api_formatAst(node, monkeyCSource = null) {
     /*
      * The estree printer sometimes looks at the parent node without
@@ -2454,9 +2544,10 @@ function handleException(state, node, exception) {
             exception = new Error(message);
         }
     }
-    finally {
+    catch (ex) {
         throw exception;
     }
+    throw exception;
 }
 function findUsing(state, stack, using) {
     if (using.module)
@@ -2503,9 +2594,9 @@ function findUsingForNode(state, stack, i, node, isType) {
             for (let j = si.imports.length; j--;) {
                 const using = si.imports[j];
                 const module = findUsing(state, stack, using);
-                if (using.module) {
-                    if (api_hasProperty(using.module.type_decls, node.name)) {
-                        return using.module.type_decls[node.name];
+                if (module) {
+                    if (api_hasProperty(module.type_decls, node.name)) {
+                        return module.type_decls[node.name];
                     }
                 }
             }

package/build/optimizer.cjs

@@ -9858,7 +9858,7 @@ const external_util_cjs_namespaceObject = require("./util.cjs");
 async function build_project(product, options, lineCallback) {
     const { workspace, program, jungleFiles, developerKeyPath, simulatorBuild, releaseBuild, testBuild, compilerOptions, compilerWarnings, typeCheckLevel, returnCommand, } = options;
     const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
-    let extraArgs = [];
+    const extraArgs = [];
     if (compilerOptions) {
         extraArgs.push(...compilerOptions.split(/\s+/));
     }
@@ -9894,6 +9894,9 @@ async function build_project(product, options, lineCallback) {
     else if (testBuild) {
         throw new Error("Building for tests requires a device to build for!");
     }
+    if (!program || !jungleFiles || !developerKeyPath || !workspace) {
+        throw new Error("Required arguments were missing!");
+    }
     const exe = external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "monkeyc.bat" : "monkeyc");
     const args = [
         ["-o", program],
@@ -9928,9 +9931,8 @@ async function readManifest(manifest) {
     return (0,xml2js.parseStringPromise)(data.toString(), { trim: true });
 }
 async function writeManifest(filename, xml) {
-    let builder = new xml2js.Builder();
-    let text = builder.buildObject(xml);
-    return promises_namespaceObject.writeFile(filename, text);
+    const builder = new xml2js.Builder();
+    return promises_namespaceObject.writeFile(filename, builder.buildObject(xml));
 }
 function manifestProducts(manifest) {
     const app = manifest["iq:manifest"]["iq:application"] ||
@@ -10228,7 +10230,7 @@ function resolve_node_by_path(state, path) {
         }
         if (!s[n] && s["."]) {
             const sdot = s["."];
-            let resolved = resolve_node_list(state, sdot);
+            const resolved = resolve_node_list(state, sdot);
             if (!resolved.length)
                 return undefined;
             const r = resolved[0][n];
@@ -10317,11 +10319,11 @@ async function resolve_literals(qualifier, default_source, deviceInfo) {
                 return resolve_file_list(v.values);
             }
             let resolved = resolve_filename(v, default_source);
-            if (/[*?\[\]\{\}]/.test(resolved)) {
+            if (/[*?[\]{}]/.test(resolved)) {
                 // Jungle files can contain "./**.mc" which is supposed to match
                 // any mc file under "./". The standard way to express that
                 // is "./**/*.mc", which is what glob expects, so translate.
-                resolved = resolved.replace(/[\\\/]\*\*([^\\\/])/g, "/**/*$1");
+                resolved = resolved.replace(/[\\/]\*\*([^\\/])/g, "/**/*$1");
                 const match = await (0,external_util_cjs_namespaceObject.globa)(resolved);
                 return match.length ? resolved : null;
             }
@@ -10595,7 +10597,7 @@ function resolve_barrel(barrel, barrelDir, products, options) {
         const sha1 = external_crypto_namespaceObject.createHash("sha1")
             .update(barrel, "binary")
             .digest("base64")
-            .replace(/[\/=+]/g, "");
+            .replace(/[/=+]/g, "");
         const localPath = external_path_.resolve(barrelDir, `${external_path_.basename(barrel, ".barrel")}-${sha1}`);
         rawBarrel = external_path_.resolve(localPath, "barrel.jungle");
         promise = promise.then(() => promises_namespaceObject.stat(localPath)
@@ -10745,7 +10747,9 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
             targets.push({ product, qualifier, shape });
             return resolve_barrels(product, qualifier, barrels, products, options);
         })
-            .then(() => { });
+            .then(() => {
+            return;
+        });
     };
     products.forEach((product) => {
         if ((0,external_api_cjs_namespaceObject.hasProperty)(state, product)) {
@@ -10788,11 +10792,151 @@ function simulateProgram(prg, device, test = false, logger) {
     const args = [prg, device];
     if (test)
         args.push("-t");
-    return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", "monkeydo"), args, logger || ((line) => console.log(line))).then(() => { }));
+    return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", "monkeydo"), args, logger || ((line) => console.log(line))).then(() => {
+        return;
+    }));
+}
+
+;// CONCATENATED MODULE: ./src/ast.ts
+/*
+ * This ensures that mctreeTypeInfo has every key of MCTreeTypeInfo,
+ * and that the corresponding arrays contain every element of the
+ * corresponding type.
+ *
+ * ie, any time mctree.Node changes, we'll get errors here if
+ * mctreeTypeInfo needs updating.
+ *
+ */
+function _check(x) {
+    const y = x;
+    x = y;
+}
+const mctreeTypeInfo = {
+    ArrayExpression: ["elements"],
+    AssignmentExpression: ["left", "right"],
+    AttributeList: ["attributes"],
+    Attributes: ["elements"],
+    BinaryExpression: ["left", "right"],
+    Block: [],
+    BlockStatement: ["body", "innerComments"],
+    BreakStatement: [],
+    CallExpression: ["callee", "arguments"],
+    CatchClause: ["param", "body"],
+    CatchClauses: ["catches"],
+    ClassBody: ["body"],
+    ClassDeclaration: ["attrs", "id", "superClass", "body"],
+    ClassElement: ["item"],
+    ConditionalExpression: ["test", "consequent", "alternate"],
+    ContinueStatement: [],
+    DoWhileStatement: ["body", "test"],
+    EnumDeclaration: ["attrs", "id", "body"],
+    EnumStringBody: ["members"],
+    EnumStringMember: ["id", "init"],
+    ExpressionStatement: ["expression"],
+    ForStatement: ["init", "test", "body", "update"],
+    FunctionDeclaration: ["attrs", "id", "params", "body"],
+    Identifier: [],
+    IfStatement: ["test", "consequent", "alternate"],
+    ImportModule: ["id"],
+    InstanceOfCase: ["id"],
+    Line: [],
+    Literal: [],
+    LogicalExpression: ["left", "right"],
+    MemberExpression: ["object", "property"],
+    MethodDefinition: ["params", "returnType"],
+    ModuleDeclaration: ["attrs", "id", "body"],
+    MultiLine: [],
+    NewExpression: ["callee", "arguments"],
+    ObjectExpression: ["properties"],
+    ParenthesizedExpression: ["expression"],
+    Program: ["body", "comments"],
+    Property: ["key", "value"],
+    ReturnStatement: ["argument"],
+    SequenceExpression: ["expressions"],
+    SizedArrayExpression: ["size", "ts"],
+    SwitchCase: ["test", "consequent"],
+    SwitchStatement: ["discriminant", "cases"],
+    ThisExpression: [],
+    ThrowStatement: ["argument"],
+    TryStatement: ["block", "handler", "finalizer"],
+    TypedefDeclaration: ["attrs", "id", "ts"],
+    TypeSpecList: ["ts"],
+    TypeSpecPart: ["body", "callspec", "generics"],
+    UnaryExpression: ["argument"],
+    UpdateExpression: ["argument"],
+    Using: ["id", "as"],
+    VariableDeclaration: ["attrs", "declarations"],
+    VariableDeclarator: ["id", "init"],
+    WhileStatement: ["test", "body"],
+};
+function isMCTreeNode(node) {
+    return node ? typeof node === "object" && "type" in node : false;
+}
+/*
+ * Traverse the ast rooted at node, calling pre before
+ * visiting each node, and post after.
+ *
+ *  - if pre returns false, the node is not traversed, and
+ *    post is not called;
+ *  - if pre returns a list of child nodes, only those will
+ *    be traversed
+ *  - otherwise all child nodes are traversed
+ *
+ *  - if post returns false, the node it was called on is
+ *    removed.
+ */
+function traverseAst(node, pre, post) {
+    const nodes = pre && pre(node);
+    if (nodes === false)
+        return;
+    if (!mctreeTypeInfo[node.type]) {
+        throw new Error("what?");
+    }
+    for (const key of nodes || mctreeTypeInfo[node.type]) {
+        const value = node[key];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            const values = value;
+            const deletions = values.reduce((state, obj, i) => {
+                if (isMCTreeNode(obj)) {
+                    const repl = traverseAst(obj, pre, post);
+                    if (repl === false) {
+                        if (!state)
+                            state = {};
+                        state[i] = true;
+                    }
+                    else if (repl != null) {
+                        if (!state)
+                            state = {};
+                        values[i] = repl;
+                    }
+                }
+                return state;
+            }, null);
+            if (deletions) {
+                values.splice(0, values.length, ...values.filter((obj, i) => deletions[i] !== true).flat(1));
+            }
+        }
+        else if (isMCTreeNode(value)) {
+            const repl = traverseAst(value, pre, post);
+            if (repl === false) {
+                delete node[key];
+            }
+            else if (repl != null) {
+                if (Array.isArray(repl)) {
+                    throw new Error("Array returned by traverseAst in Node context");
+                }
+                node[key] = repl;
+            }
+        }
+    }
+    return post && post(node);
 }
 
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
+
 function renameVariable(state, locals, declName) {
     const map = locals.map;
     if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, declName))
@@ -10809,7 +10953,7 @@ function renameVariable(state, locals, declName) {
         // more conflicts
         locals.inners = {};
         const inners = locals.inners;
-        (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
+        traverseAst(locals.node, (node) => {
             if (node.type === "VariableDeclarator") {
                 inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
             }
@@ -10849,6 +10993,7 @@ function renameVariable(state, locals, declName) {
 ;// 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.
@@ -10916,25 +11061,12 @@ function getArgSafety(state, func, args, requireAll) {
     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) => {
+    traverseAst(func.node.body, null, (node) => {
         switch (node.type) {
             case "AssignmentExpression":
             case "UpdateExpression": {
@@ -11207,7 +11339,7 @@ function inlineWithArgs(state, func, call, context) {
         }
     }
     else {
-        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+        traverseAst(func.node.body, (node) => {
             node.type === "ReturnStatement" && retStmtCount++;
         });
         if (retStmtCount > 1) {
@@ -11442,6 +11574,20 @@ function visitReferences(state, ast, name, defn, callback) {
                     return ["object"];
                 }
                 break;
+            case "MethodDefinition": {
+                if (!state.inType) {
+                    throw new Error("Method definition outside of type!");
+                }
+                if (node.params) {
+                    node.params.forEach((param) => {
+                        if (param.type == "BinaryExpression") {
+                            state.traverse(param.right);
+                            state.inType = true;
+                        }
+                    });
+                }
+                return ["returnType"];
+            }
         }
         return null;
     };
@@ -11457,6 +11603,7 @@ function visitReferences(state, ast, name, defn, callback) {
 
 
 
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -11537,7 +11684,9 @@ function getFileSources(fnMap) {
         return (value.monkeyCSource ||
             promises_namespaceObject.readFile(name)
                 .then((data) => (value.monkeyCSource = data.toString().replace(/\r\n/g, "\n"))));
-    })).then(() => { });
+    })).then(() => {
+        return;
+    });
 }
 function getFileASTs(fnMap) {
     return getFileSources(fnMap).then(() => Object.entries(fnMap).reduce((ok, [name, value]) => {
@@ -11600,6 +11749,7 @@ async function analyze(fnMap, barrelList, config) {
                         node.body = null;
                         break;
                     }
+                // falls through
                 case "ModuleDeclaration":
                 case "ClassDeclaration": {
                     const [scope] = state.stack.slice(-1);
@@ -11643,7 +11793,7 @@ async function analyze(fnMap, barrelList, config) {
     if (diagnosticType &&
         !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
         const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
-        Object.entries(fnMap).forEach(([k, v]) => {
+        Object.entries(fnMap).forEach(([, v]) => {
             visitReferences(state, v.ast, null, false, (node, results, error) => {
                 if (!error)
                     return undefined;
@@ -11849,7 +11999,7 @@ function evaluateFunction(func, args) {
         ? JSON.parse(JSON.stringify(func.body))
         : func.body;
     try {
-        (0,external_api_cjs_namespaceObject.traverseAst)(body, (node) => {
+        traverseAst(body, (node) => {
             switch (node.type) {
                 case "BlockStatement":
                 case "ReturnStatement":
@@ -11988,7 +12138,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             case "ConditionalExpression":
             case "IfStatement":
             case "DoWhileStatement":
-            case "WhileStatement":
+            case "WhileStatement": {
                 const test = (state.traverse(node.test) ||
                     node.test);
                 const [value, type] = getNodeValue(test);
@@ -12020,6 +12170,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     }
                 }
                 return null;
+            }
             case "EnumDeclaration":
                 return false;
             case "ForStatement": {
@@ -12331,7 +12482,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         return null;
     };
     Object.values(fnMap).forEach((f) => {
-        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
+        traverseAst(f.ast, undefined, (node) => {
             const ret = cleanup(node);
             if (ret === false) {
                 state.removeNodeComments(node, f.ast);
@@ -12388,6 +12539,7 @@ function optimizeCall(state, node, context) {
 
 ;// CONCATENATED MODULE: ./src/pragma-checker.ts
 
+
 function pragmaChecker(ast, diagnostics) {
     const comments = ast.comments;
     if (!comments)
@@ -12434,7 +12586,7 @@ function pragmaChecker(ast, diagnostics) {
         return re.test(haystack);
     };
     next();
-    (0,external_api_cjs_namespaceObject.traverseAst)(ast, (node) => {
+    traverseAst(ast, (node) => {
         if (index >= comments.length)
             return false;
         if (node.start && node.start >= (comment.end || Infinity)) {
@@ -12513,7 +12665,7 @@ function pragmaChecker(ast, diagnostics) {
 
 
 function relative_path_no_dotdot(relative) {
-    return relative.replace(/^(\.\.[\\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
+    return relative.replace(/^(\.\.[\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
 }
 async function getVSCodeSettings(path) {
     try {
@@ -12645,7 +12797,7 @@ async function createLocalBarrels(targets, options) {
             const sha1 = external_crypto_namespaceObject.createHash("sha1")
                 .update(rawBarrelDir, "binary")
                 .digest("base64")
-                .replace(/[\/=+]/g, "");
+                .replace(/[/=+]/g, "");
             const optBarrelDir = external_path_.resolve(barrelDir, `${barrel}-${sha1}`);
             if (!(0,external_api_cjs_namespaceObject.hasProperty)(optBarrels, barrel)) {
                 optBarrels[barrel] = {
@@ -12693,7 +12845,9 @@ async function generateOptimizedProject(options) {
         }
         return {
             jungleFiles: config.jungleFiles,
+            xml,
             program: external_path_.basename(external_path_.dirname(manifest)),
+            hasTests: !!config.testBuild,
         };
     }
     let dropBarrels = false;
@@ -12794,7 +12948,7 @@ async function generateOptimizedProject(options) {
         }
         const prefix = `${product}.`;
         process_field(prefix, qualifier, "sourcePath", (s) => external_path_.join(group.dir, "source", relative_path_no_dotdot(external_path_.relative(workspace, s)))
-            .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1"));
+            .replace(/([\\/]\*\*)[\\/]\*/g, "$1"));
         if (group.optimizerConfig.optBarrels) {
             parts.push(`${prefix}barrelPath = ${Object.values(group.optimizerConfig.optBarrels)
                 .map((value) => `[${value.jungleFiles
@@ -12808,7 +12962,7 @@ async function generateOptimizedProject(options) {
                 .map(([barrel, resolvedBarrel]) => {
                 const root = external_path_.dirname(resolvedBarrel.jungles[0]);
                 return (resolvedBarrel.qualifier.sourcePath || []).map((s) => external_path_.join(group.dir, "barrels", barrel, external_path_.relative(root, s))
-                    .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1"));
+                    .replace(/([\\/]\*\*)[\\/]\*/g, "$1"));
             })
                 .flat()
                 .sort()
@@ -12931,7 +13085,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 && 1655479110007 < opt_time) {
+        if (source_time < opt_time && 1655677006664 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }

package/build/src/api.d.ts

@@ -1,5 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { traverseAst } from "./ast";
 export { visitReferences } from "./visitor";
+export { traverseAst };
 export declare function getApiMapping(state?: ProgramState, barrelList?: string[]): Promise<ProgramStateNode | null>;
 export declare function hasProperty<T extends null extends T ? unknown : undefined extends T ? unknown : never>(obj: T, prop: string): obj is NonNullable<T>;
 export declare function hasProperty<T>(obj: T, prop: string): boolean;
@@ -7,6 +9,5 @@ export declare function isStateNode(node: StateNodeDecl): node is StateNode;
 export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
 export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
 export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
-export declare function traverseAst(node: mctree.Node, pre?: null | ((node: mctree.Node) => void | null | false | (keyof mctree.NodeAll)[]), post?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[]): false | void | null | mctree.Node | mctree.Node[];
 export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null): string;
 export declare function findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier, isType: boolean): StateNodeDecl[] | null;

package/build/src/ast.d.ts

@@ -0,0 +1,2 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function traverseAst(node: mctree.Node, pre?: null | ((node: mctree.Node) => void | null | false | (keyof mctree.NodeAll)[]), post?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[]): false | void | null | mctree.Node | mctree.Node[];

package/build/src/optimizer.d.ts

@@ -197,7 +197,7 @@ export declare function buildOptimizedProject(product: string | null, options: B
     args: string[];
     program: string;
     product: string | null;
-    hasTests: boolean | undefined;
+    hasTests: boolean;
     diagnostics: Record<string, {
         type: DiagnosticType;
         loc: {
@@ -209,9 +209,9 @@ export declare function buildOptimizedProject(product: string | null, options: B
 }>;
 export declare function generateOptimizedProject(options: BuildConfig): Promise<{
     jungleFiles: string | undefined;
+    xml: import("./manifest").ManifestXML;
     program: string;
-    xml?: undefined;
-    hasTests?: undefined;
+    hasTests: boolean;
     diagnostics?: undefined;
 } | {
     jungleFiles: string;

package/build/util.cjs

@@ -4145,10 +4145,12 @@ async function copyRecursiveAsNeeded(source, target, filter) {
         }
         const files = await promises_namespaceObject.readdir(source);
         return Promise.all(files.map((file) => {
-            var src = external_path_.join(source, file);
-            var tgt = external_path_.join(target, file);
+            const src = external_path_.join(source, file);
+            const tgt = external_path_.join(target, file);
             return copyRecursiveAsNeeded(src, tgt, filter);
-        })).then(() => { });
+        })).then(() => {
+            return;
+        });
     }
     else {
         if (filter && !filter(source, target)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -20,9 +20,12 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-inline && npm run test-remote",
+    "test": "npm run test-optimized && 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"
+    "test-optimized": "node test/test.js --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
+    "test-unopt": "node test/test.js --skipOptimization --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
+    "test-garmin-opt": "node test/test.js --skipOptimization --garminOptLevel=2 --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
+    "eslint": "npx eslint ."
   },
   "files": [
     "build/optimizer.cjs",
@@ -34,12 +37,14 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.26"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.27"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",
     "@types/prettier": "^2.6.1",
     "@types/xml2js": "^0.4.11",
+    "@typescript-eslint/eslint-plugin": "^5.28.0",
+    "@typescript-eslint/parser": "^5.28.0",
     "eslint": "^8.12.0",
     "extract-zip": "^2.0.1",
     "glob": "^7.2.0",