@markw65/monkeyc-optimizer 1.0.37 → 1.0.39

package/build/api.cjs

@@ -1,8 +1,8 @@
-0 && (module.exports = {collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,sameLookupResult,traverseAst,variableDeclarationName,visitReferences});
+0 && (module.exports = {collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 2789:
+/***/ 789:
 /***/ ((module) => {
 
 /**
@@ -270,7 +270,8 @@ __webpack_require__.d(__webpack_exports__, {
   "sameLookupResult": () => (/* binding */ api_sameLookupResult),
   "traverseAst": () => (/* reexport */ ast_traverseAst),
   "variableDeclarationName": () => (/* binding */ api_variableDeclarationName),
-  "visitReferences": () => (/* reexport */ visitor_visitReferences)
+  "visitReferences": () => (/* reexport */ visitor_visitReferences),
+  "visitorNode": () => (/* reexport */ visitorNode)
 });
 
 ;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
@@ -655,8 +656,13 @@ function function_info_findCalleesForNew(lookupDefs) {
 
 function variable_renamer_renameVariable(state, locals, declName) {
     const map = locals.map;
-    if (!hasProperty(map, declName))
-        return null;
+    if (declName) {
+        if (!hasProperty(map, declName))
+            return null;
+    }
+    else {
+        declName = "tmp";
+    }
     let suffix = 0;
     let node_name = declName;
     const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
@@ -711,6 +717,69 @@ function variable_renamer_renameVariable(state, locals, declName) {
 
 
 
+// Note: Keep in sync with replaceInlinedSubExpression below
+function inliner_inlinableSubExpression(expr) {
+    while (true) {
+        if (expr.type === "BinaryExpression" || expr.type === "LogicalExpression") {
+            expr = expr.left;
+        }
+        else if (expr.type === "UnaryExpression") {
+            expr = expr.argument;
+        }
+        else if (expr.type === "ConditionalExpression") {
+            expr = expr.test;
+        }
+        else if (expr.type === "MemberExpression") {
+            expr = expr.object;
+        }
+        else if (expr.type === "CallExpression") {
+            return expr;
+        }
+        else {
+            return null;
+        }
+    }
+}
+// Note: Keep in sync with inlinableSubExpression above
+function replaceInlinedSubExpression(top, call, repl) {
+    if (top === call)
+        return repl;
+    let expr = top;
+    while (true) {
+        if (expr.type === "LogicalExpression" || expr.type === "BinaryExpression") {
+            if (expr.left === call) {
+                expr.left = repl;
+                break;
+            }
+            expr = expr.left;
+        }
+        else if (expr.type === "UnaryExpression") {
+            if (expr.argument === call) {
+                expr.argument = repl;
+                break;
+            }
+            expr = expr.argument;
+        }
+        else if (expr.type === "ConditionalExpression") {
+            if (expr.test === call) {
+                expr.test = repl;
+                break;
+            }
+            expr = expr.test;
+        }
+        else if (expr.type === "MemberExpression") {
+            if (expr.object === call) {
+                expr.object = repl;
+                break;
+            }
+            expr = expr.object;
+        }
+        else {
+            throw new Error("Internal error: Didn't find CallExpression");
+        }
+    }
+    return top;
+}
 function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
@@ -938,7 +1007,7 @@ function inliner_shouldInline(state, func, call, context) {
             }
         }
         if (!context && requested) {
-            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, if or return contexts");
         }
         return context != null;
     }
@@ -1137,6 +1206,9 @@ function inliner_unused(expression, top) {
             if (expression.computed) {
                 return inliner_unused(expression.object).concat(inliner_unused(expression.property));
             }
+            if (expression.object.type === "NewExpression") {
+                break;
+            }
             return inliner_unused(expression.object);
         case "ArrayExpression":
             return expression.elements.map((e) => inliner_unused(e)).flat(1);
@@ -1198,7 +1270,8 @@ function inlineWithArgs(state, func, call, context) {
             inlineDiagnostic(state, func, call, "Function had more than one return statement");
         }
         else if ((context.type === "AssignmentExpression" ||
-            context.type === "VariableDeclarator") &&
+            context.type === "VariableDeclarator" ||
+            context.type === "IfStatement") &&
             retStmtCount !== 1) {
             inlineDiagnostic(state, func, call, "Function did not have a return statement");
             return null;
@@ -1208,7 +1281,8 @@ function inlineWithArgs(state, func, call, context) {
             if (!last ||
                 last.type !== "ReturnStatement" ||
                 ((context.type === "AssignmentExpression" ||
-                    context.type === "VariableDeclarator") &&
+                    context.type === "VariableDeclarator" ||
+                    context.type === "IfStatement") &&
                     !last.argument)) {
                 inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
                 return null;
@@ -1235,14 +1309,15 @@ function inlineWithArgs(state, func, call, context) {
         }
         if (last.argument) {
             if (context.type === "AssignmentExpression") {
-                context.right = last.argument;
+                context.right = replaceInlinedSubExpression(context.right, call, last.argument);
                 block.body[block.body.length - 1] = {
                     type: "ExpressionStatement",
                     expression: context,
                 };
             }
             else if (context.type === "VariableDeclarator") {
-                const { id, init: _init, kind: _kind, ...rest } = context;
+                const { id, init, kind: _kind, ...rest } = context;
+                const right = replaceInlinedSubExpression(init, call, last.argument);
                 block.body[block.body.length - 1] = {
                     ...rest,
                     type: "ExpressionStatement",
@@ -1251,9 +1326,52 @@ function inlineWithArgs(state, func, call, context) {
                         type: "AssignmentExpression",
                         operator: "=",
                         left: id.type === "Identifier" ? id : id.left,
+                        right,
+                    },
+                };
+            }
+            else if (context.type === "IfStatement") {
+                // Generate a pmcr_tmp name that doesn't conflict with anything
+                const locals = state.localsStack[state.localsStack.length - 1];
+                const name = renameVariable(state, locals, null);
+                locals.map[name] = true;
+                // Replace the inlined function's return statement
+                // with an assignment to pmcr_tmp
+                block.body[block.body.length - 1] = {
+                    type: "ExpressionStatement",
+                    expression: {
+                        type: "AssignmentExpression",
+                        operator: "=",
+                        left: { type: "Identifier", name },
                         right: last.argument,
                     },
                 };
+                // The IfStatement either has the call as its test, or as
+                // the leftmost argument to a series of Binary/Logical expressions
+                // Either way, replace the call with pmcr_tmp
+                const repl = { type: "Identifier", name };
+                context.test = replaceInlinedSubExpression(context.test, call, repl);
+                // Wrap the inlined body so it looks like
+                // {
+                //   var pmcr_tmp;
+                //   { /* inlined body, with assignment to pmcr_tmp */ }
+                //   if (context) {} // original if statement
+                // }
+                body.body = [
+                    {
+                        type: "VariableDeclaration",
+                        kind: "var",
+                        declarations: [
+                            {
+                                type: "VariableDeclarator",
+                                kind: "var",
+                                id: { type: "Identifier", name },
+                            },
+                        ],
+                    },
+                    { type: "BlockStatement", body: body.body },
+                    context,
+                ];
             }
             else {
                 const side_exprs = inliner_unused(last.argument);
@@ -1427,7 +1545,7 @@ function pragma_checker_pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@(\d+)/g, "(pre_)?$1(_\\d+)?"));
+        const re = new RegExp(needle.replace(/@([\d\w]+)/g, "(pre_)?$1(_\\d+)?"));
         return re.test(haystack);
     };
     next();
@@ -2012,7 +2130,7 @@ function getPreOrder(head) {
 }
 
 // EXTERNAL MODULE: ./node_modules/priorityqueuejs/index.js
-var priorityqueuejs = __webpack_require__(2789);
+var priorityqueuejs = __webpack_require__(789);
 ;// CONCATENATED MODULE: ./src/pre.ts
 
 
@@ -3005,6 +3123,13 @@ function unused_exprs_cleanupUnusedVars(state, node) {
                     if (hasProperty(toRemove, name)) {
                         const rep = vdecl.init ? unused(vdecl.init) : [];
                         if (rep.length) {
+                            if (rep.find((s) => s.type === "ExpressionStatement" &&
+                                (s.expression.type === "NewExpression" ||
+                                    (s.expression.type === "MemberExpression" &&
+                                        !s.expression.computed &&
+                                        s.expression.object.type === "NewExpression")))) {
+                                continue;
+                            }
                             if (parent.node.type === "ForStatement") {
                                 // declarations whose inits have side effects
                                 // can't be deleted from for statements.
@@ -3054,100 +3179,6 @@ function unused_exprs_cleanupUnusedVars(state, node) {
     }
 }
 
-;// CONCATENATED MODULE: ./src/visitor.ts
-
-function visitor_visitReferences(state, ast, name, defn, callback) {
-    const checkResults = ([name, results], node) => {
-        if (name && results) {
-            if (!defn || (0,external_api_cjs_namespaceObject.sameLookupResult)(results, defn)) {
-                if (callback(node, results, false) === false) {
-                    return [];
-                }
-            }
-        }
-        else if (defn === false) {
-            if (callback(node, [], results === null) === false) {
-                return [];
-            }
-        }
-        return null;
-    };
-    state.pre = (node) => {
-        switch (node.type) {
-            case "AttributeList":
-                return [];
-            case "UnaryExpression":
-                // a bare symbol isn't a reference
-                if (node.operator === ":")
-                    return [];
-                break;
-            case "BinaryExpression":
-                /*
-                 * `expr has :symbol` can be treated as a reference
-                 * to expr.symbol.
-                 */
-                if (node.operator === "has") {
-                    if (node.right.type === "UnaryExpression" &&
-                        node.right.operator === ":") {
-                        if (!name || node.right.argument.name === name) {
-                            return checkResults(state.lookup({
-                                type: "MemberExpression",
-                                object: node.left,
-                                property: node.right.argument,
-                                computed: false,
-                            }), node.right.argument);
-                        }
-                    }
-                }
-                break;
-            case "CallExpression":
-                // A call expression whose callee is an identifier is looked
-                // up as a non-local. ie even if there's a same named local,
-                // it will be ignored, and the lookup will start as if the
-                // call had been written self.foo() rather than foo().
-                if (node.callee.type === "Identifier") {
-                    if (!name || node.callee.name === name) {
-                        /* ignore return value */
-                        checkResults(state.lookupNonlocal(node.callee), node.callee);
-                    }
-                    return ["arguments"];
-                }
-                break;
-            case "Identifier":
-                if (!name || node.name === name) {
-                    return checkResults(state.lookup(node), node);
-                }
-                break;
-            case "MemberExpression": {
-                const property = (0,external_api_cjs_namespaceObject.isLookupCandidate)(node);
-                if (property) {
-                    if (!name || property.name === name) {
-                        return checkResults(state.lookup(node), node) || ["object"];
-                    }
-                    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);
-                        }
-                    });
-                }
-                return ["returnType"];
-            }
-        }
-        return null;
-    };
-    (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
-    delete state.pre;
-}
-
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
@@ -3160,7 +3191,6 @@ 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];
@@ -3275,7 +3305,7 @@ function getFileASTs(fnMap) {
         return ok;
     }, true));
 }
-async function analyze(fnMap, barrelList, config) {
+async function analyze(fnMap, resourcesMap, config) {
     let hasTests = false;
     let markApi = true;
     const preState = {
@@ -3343,7 +3373,7 @@ async function analyze(fnMap, barrelList, config) {
             return null;
         },
     };
-    await getApiMapping(preState, barrelList);
+    await getApiMapping(preState, resourcesMap);
     markApi = false;
     const state = preState;
     await getFileASTs(fnMap);
@@ -3359,16 +3389,25 @@ async function analyze(fnMap, barrelList, config) {
     delete state.shouldExclude;
     delete state.pre;
     collectClassInfo(state);
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
+    return state;
+}
+function reportMissingSymbols(state, config) {
     const diagnosticType = config?.checkInvalidSymbols !== "OFF"
         ? config?.checkInvalidSymbols || "WARNING"
         : null;
     if (diagnosticType &&
         !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
         const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
-        Object.entries(fnMap).forEach(([, v]) => {
+        Object.entries(state.fnMap).forEach(([, v]) => {
             visitReferences(state, v.ast, null, false, (node, results, error) => {
                 if (!error)
                     return undefined;
+                if (node.type === "BinaryExpression" && node.operator === "has") {
+                    // Its not an error to check whether a property exists...
+                    return undefined;
+                }
                 const nodeStr = formatAst(node);
                 if (state.inType) {
                     if (!checkTypes || nodeStr.match(/^Void|Null$/)) {
@@ -3380,9 +3419,6 @@ async function analyze(fnMap, barrelList, config) {
             });
         });
     }
-    state.exposed = state.nextExposed;
-    state.nextExposed = {};
-    return state;
 }
 function compareLiteralLike(a, b) {
     while (a.type === "BinaryExpression")
@@ -3676,8 +3712,8 @@ function markFunctionCalled(state, func) {
     }
     pushUnique(state.calledFunctions[func.id.name], func);
 }
-async function optimizeMonkeyC(fnMap, barrelList, config) {
-    const state = (await analyze(fnMap, barrelList, config));
+async function optimizeMonkeyC(fnMap, resourcesMap, config) {
+    const state = (await analyze(fnMap, resourcesMap, config));
     state.localsStack = [{}];
     state.calledFunctions = {};
     state.usedByName = {};
@@ -4048,11 +4084,18 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         return false;
                     return replace(rep, rep);
                 }
-                else if (node.type === "IfStatement" &&
-                    node.alternate &&
-                    node.alternate.type === "BlockStatement" &&
-                    !node.alternate.body.length) {
-                    delete node.alternate;
+                else if (node.type === "IfStatement") {
+                    if (node.alternate &&
+                        node.alternate.type === "BlockStatement" &&
+                        !node.alternate.body.length) {
+                        delete node.alternate;
+                    }
+                    else {
+                        const call = inlinableSubExpression(node.test);
+                        if (call) {
+                            return replace(optimizeCall(state, call, node), node.test);
+                        }
+                    }
                 }
                 break;
             case "WhileStatement":
@@ -4070,6 +4113,37 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     return replace(optimizeCall(state, node.argument, node), node.argument);
                 }
                 break;
+            case "BinaryExpression":
+                if (node.operator === "has" &&
+                    node.right.type === "UnaryExpression" &&
+                    node.right.operator === ":") {
+                    const [, results] = state.lookup(node.left);
+                    if (results &&
+                        results.length === 1 &&
+                        results[0].results.length === 1) {
+                        const obj = results[0].results[0];
+                        if ((obj.type === "ModuleDeclaration" ||
+                            obj.type === "Program" ||
+                            obj.type === "ClassDeclaration") &&
+                            obj.decls &&
+                            obj.stack) {
+                            const exists = hasProperty(obj.decls, node.right.argument.name) ||
+                                // This is overkill, since we've already looked up
+                                // node.left, but the actual lookup rules are complicated,
+                                // and embedded within state.lookup; so just defer to that.
+                                state.lookup({
+                                    type: "MemberExpression",
+                                    object: node.left,
+                                    property: node.right.argument,
+                                    computed: false,
+                                })[1];
+                            if (!exists) {
+                                return replace({ type: "Literal", value: false, raw: "false" }, node);
+                            }
+                        }
+                    }
+                }
+                break;
             case "NewExpression":
                 if (state.currentFunction) {
                     const [, results] = state.lookup(node.callee);
@@ -4095,8 +4169,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     let j = 0;
                     while (i < node.declarations.length) {
                         const decl = declarations[i++];
-                        if (decl.init && decl.init.type === "CallExpression") {
-                            const inlined = replace(optimizeCall(state, decl.init, decl), decl.init);
+                        if (!decl.init)
+                            continue;
+                        const call = inlinableSubExpression(decl.init);
+                        if (call) {
+                            const inlined = replace(optimizeCall(state, call, decl), decl.init);
                             if (!inlined)
                                 continue;
                             if (Array.isArray(inlined) || inlined.type != "BlockStatement") {
@@ -4131,7 +4208,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     return replace(optimizeCall(state, node.expression, node), node.expression);
                 }
                 else if (node.expression.type === "AssignmentExpression") {
-                    if (node.expression.right.type === "CallExpression") {
+                    const call = inlinableSubExpression(node.expression.right);
+                    if (call) {
                         let ok = false;
                         if (node.expression.left.type === "Identifier") {
                             if (hasProperty(topLocals().map, node.expression.left.type)) {
@@ -4143,7 +4221,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                             ok = !!result;
                         }
                         if (ok) {
-                            return replace(optimizeCall(state, node.expression.right, node.expression), node.expression.right);
+                            return replace(optimizeCall(state, call, node.expression), node.expression.right);
                         }
                     }
                 }
@@ -4293,7 +4371,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         }
         return null;
     };
-    Object.entries(fnMap).forEach(([name, f]) => {
+    Object.entries(fnMap).forEach(([, f]) => {
         traverseAst(f.ast, undefined, (node) => {
             const ret = cleanup(node);
             if (ret === false) {
@@ -4301,6 +4379,9 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             }
             return ret;
         });
+    });
+    reportMissingSymbols(state, config);
+    Object.entries(fnMap).forEach(([name, f]) => {
         if (state.config && state.config.checkBuildPragmas) {
             pragmaChecker(state, f.ast, state.diagnostics?.[name]);
         }
@@ -4416,6 +4497,316 @@ const negativeFixups = [
 
 ;// CONCATENATED MODULE: external "./sdk-util.cjs"
 const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
+;// CONCATENATED MODULE: ./src/resources.ts
+
+
+/*
+ * This is unavoidably ad-hoc. Garmin has arbitrary rules for how
+ * resources can be nested, which we need to mimic here.
+ */
+function visit_resources(elements, parent, visitor, error) {
+    elements.forEach((e) => {
+        switch (e.name) {
+            // <resources> can contain any of the resource lists (except
+            // another resources), and any of their contents
+            case "resources":
+                if (parent) {
+                    error(e, parent);
+                    return;
+                }
+                visit_resources(external_sdk_util_cjs_namespaceObject.xmlUtil.elementKids(e), "resources", visitor, error);
+                return;
+            // Each of these is a list that can contain certain kinds of resource.
+            // They can only occur at the top level, or under a <resources> list.
+            case "strings":
+            case "fonts":
+            case "animations":
+            case "bitmaps":
+            case "layouts":
+            case "menus":
+            case "drawables":
+            case "properties":
+            case "settings":
+            case "fitContributions":
+            case "jsonDataResources":
+            case "complications":
+                if (parent && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visit_resources(external_sdk_util_cjs_namespaceObject.xmlUtil.elementKids(e), e.name, visitor, error);
+                return;
+            // These are the resources themselves. Some can occur at top level; most
+            // are restricted to <resources> or one or more of the specific lists above
+            case "string":
+                if (parent !== "strings" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Strings");
+                return;
+            case "font":
+                if (parent !== "fonts" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Fonts");
+                return;
+            case "animation":
+                if (parent !== "animations" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Drawables");
+                return;
+            case "menu":
+            case "menu2":
+            case "checkbox-menu":
+            case "action-menu":
+                if (parent && parent !== "menus" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Menus");
+                return;
+            case "bitmap":
+                if (parent !== "bitmaps" &&
+                    parent !== "drawables" &&
+                    parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Drawables");
+                return;
+            case "layout":
+                if (parent && parent !== "layouts" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Layouts");
+                return;
+            case "drawable-list":
+                if (parent && parent !== "drawables" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Drawables");
+                return;
+            case "property":
+                if (parent !== "properties" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "Properties");
+                return;
+            case "setting":
+                if (parent !== "settings" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, null);
+                return;
+            case "group":
+                if (parent !== "settings" /* && parent !== "resources" */) {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, null);
+                return;
+            case "fitField":
+                if (parent !== "fitContributions" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, null);
+                return;
+            case "jsonData":
+                if (parent && parent != "jsonDataResources" && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, "JsonData");
+                return;
+            case "build":
+                if (parent && parent !== "resources") {
+                    error(e, parent);
+                    return;
+                }
+                visitor(e, null);
+                return;
+        }
+    });
+}
+function add_resources_to_ast(ast, resources) {
+    Object.entries(resources).forEach(([barrel, resourceMap]) => {
+        const rezModules = {
+            Drawables: [],
+            Fonts: [],
+            JsonData: [],
+            Layouts: [],
+            Menus: [],
+            Properties: [],
+            Strings: [],
+        };
+        Object.values(resourceMap).forEach((rez) => {
+            if (!rez || !(rez instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Document))
+                return;
+            visit_resources(rez.body.elements, null, (e, s) => {
+                if (!s)
+                    return;
+                if (!ast_hasProperty(rezModules, s))
+                    return;
+                rezModules[s].push(e);
+            }, (_e, _s) => {
+                return;
+            });
+        });
+        const outerLoc = ast.loc && { ...ast.loc };
+        const makeModule = (m) => ({
+            type: "ModuleDeclaration",
+            id: { type: "Identifier", name: m },
+            body: { type: "BlockStatement", body: [] },
+            loc: outerLoc,
+        });
+        let body = ast.body;
+        if (barrel !== "") {
+            const module = makeModule(barrel);
+            body.push(module);
+            body = module.body.body;
+        }
+        const rez = makeModule("Rez");
+        body.push(rez);
+        body = rez.body.body;
+        Object.entries(rezModules).forEach(([m, elements]) => {
+            const module = makeModule(m);
+            body.push(module);
+            elements.forEach((e) => e.attr.id &&
+                module.body.body.push({
+                    type: "VariableDeclaration",
+                    declarations: [
+                        {
+                            type: "VariableDeclarator",
+                            kind: "var",
+                            id: { type: "Identifier", name: e.attr.id, loc: e.loc },
+                            loc: e.loc,
+                        },
+                    ],
+                    kind: "var",
+                    loc: e.loc,
+                }));
+        });
+    });
+}
+
+;// CONCATENATED MODULE: ./src/visitor.ts
+
+function visitorNode(node) {
+    if (node.type === "Identifier") {
+        return node;
+    }
+    if (node.type === "MemberExpression") {
+        return node.property;
+    }
+    if (node.type === "BinaryExpression" &&
+        node.operator === "has" &&
+        node.right.type === "UnaryExpression" &&
+        node.right.operator === ":") {
+        return node.right.argument;
+    }
+    return node;
+}
+function visitor_visitReferences(state, ast, name, defn, callback) {
+    const checkResults = ([name, results], node) => {
+        if (name && results) {
+            if (!defn || (0,external_api_cjs_namespaceObject.sameLookupResult)(results, defn)) {
+                if (callback(node, results, false) === false) {
+                    return [];
+                }
+            }
+        }
+        else if (defn === false) {
+            if (callback(node, [], results === null) === false) {
+                return [];
+            }
+        }
+        return null;
+    };
+    state.pre = (node) => {
+        switch (node.type) {
+            case "AttributeList":
+                return [];
+            case "UnaryExpression":
+                // a bare symbol isn't a reference
+                if (node.operator === ":")
+                    return [];
+                break;
+            case "BinaryExpression":
+                /*
+                 * `expr has :symbol` can be treated as a reference
+                 * to expr.symbol.
+                 */
+                if (node.operator === "has") {
+                    if (node.right.type === "UnaryExpression" &&
+                        node.right.operator === ":") {
+                        if (!name || node.right.argument.name === name) {
+                            return checkResults(state.lookup({
+                                type: "MemberExpression",
+                                object: node.left,
+                                property: node.right.argument,
+                                computed: false,
+                            }), node);
+                        }
+                    }
+                }
+                break;
+            case "CallExpression":
+                // A call expression whose callee is an identifier is looked
+                // up as a non-local. ie even if there's a same named local,
+                // it will be ignored, and the lookup will start as if the
+                // call had been written self.foo() rather than foo().
+                if (node.callee.type === "Identifier") {
+                    if (!name || node.callee.name === name) {
+                        /* ignore return value */
+                        checkResults(state.lookupNonlocal(node.callee), node.callee);
+                    }
+                    return ["arguments"];
+                }
+                break;
+            case "Identifier":
+                if (!name || node.name === name) {
+                    return checkResults(state.lookup(node), node);
+                }
+                break;
+            case "MemberExpression": {
+                const property = (0,external_api_cjs_namespaceObject.isLookupCandidate)(node);
+                if (property) {
+                    if (!name || property.name === name) {
+                        return checkResults(state.lookup(node), node) || ["object"];
+                    }
+                    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);
+                        }
+                    });
+                }
+                return ["returnType"];
+            }
+        }
+        return null;
+    };
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
+    delete state.pre;
+}
+
 ;// CONCATENATED MODULE: ./src/api.ts
 
 
@@ -4428,6 +4819,7 @@ 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
@@ -4438,34 +4830,24 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
  * but those are at least in a standard format.
  */
 // Extract all enum values from api.mir
-async function api_getApiMapping(state, barrelList) {
+async function api_getApiMapping(state, resourcesMap) {
     // get the path to the currently active sdk
     const parser = (prettier_plugin_monkeyc_default()).parsers.monkeyc;
     const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
-    const rezDecl = `module Rez { ${[
-        "Drawables",
-        "Fonts",
-        "JsonData",
-        "Layouts",
-        "Menus",
-        "Strings",
-    ]
-        .map((s) => `  module ${s} {}\n`)
-        .join("")}}`;
     const api = (await promises_namespaceObject.readFile(`${sdk}bin/api.mir`))
         .toString()
         .replace(/\r\n/g, "\n")
         .replace(/^\s*\[.*?\]\s*$/gm, "")
         //.replace(/(COLOR_TRANSPARENT|LAYOUT_[HV]ALIGN_\w+) = (\d+)/gm, "$1 = -$2")
-        .replace(/^(\s*type)\s/gm, "$1def ") +
-        (barrelList || [])
-            .map((name) => `module ${name} { ${rezDecl} }`)
-            .concat(rezDecl)
-            .join("");
+        .replace(/^(\s*type)\s/gm, "$1def ");
     try {
-        const result = api_collectNamespaces(parser.parse(api, null, {
+        const ast = parser.parse(api, null, {
             filepath: "api.mir",
-        }), state);
+        });
+        if (resourcesMap) {
+            add_resources_to_ast(ast, resourcesMap);
+        }
+        const result = api_collectNamespaces(ast, state);
         negativeFixups.forEach((fixup) => {
             const vs = fixup.split(".").reduce((state, part) => {
                 const decls = api_isStateNode(state) && state.decls?.[part];
@@ -4635,14 +5017,11 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
                     return current ? current.concat(items) : items;
                 }, null);
                 if (!result &&
-                    results.some((ld) => ld.results.some((sn) => (api_isStateNode(sn) && sn.fullName?.match(/^\$\.(\w+\.)?Rez\./)) ||
-                        sn.type === "VariableDeclarator" ||
+                    results.some((ld) => ld.results.some((sn) => sn.type === "VariableDeclarator" ||
                         sn.type === "Identifier" ||
                         sn.type === "BinaryExpression" ||
                         (sn.type === "ClassDeclaration" &&
                             property.name === "initialize")))) {
-                    // - The Rez module can contain lots of things from the resource
-                    //   compiler which we don't track.
                     // - Variables, and formal parameters would require type tracking
                     //   which we don't yet do
                     // - Its ok to call an undeclared initialize method.
@@ -4656,7 +5035,7 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
         }
         case "ThisExpression": {
             for (let i = stack.length;;) {
-                const si = stack[i];
+                const si = stack[--i];
                 if (si.type == "ModuleDeclaration" ||
                     si.type == "ClassDeclaration" ||
                     !i) {