@markw65/monkeyc-optimizer 1.0.38 → 1.0.40

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 = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 2789:
+/***/ 789:
 /***/ ((module) => {
 
 /**
@@ -258,6 +258,7 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  "checkCompilerVersion": () => (/* binding */ api_checkCompilerVersion),
   "collectNamespaces": () => (/* binding */ api_collectNamespaces),
   "findUsingForNode": () => (/* binding */ findUsingForNode),
   "formatAst": () => (/* binding */ api_formatAst),
@@ -267,10 +268,12 @@ __webpack_require__.d(__webpack_exports__, {
   "isLookupCandidate": () => (/* binding */ api_isLookupCandidate),
   "isStateNode": () => (/* binding */ api_isStateNode),
   "markInvokeClassMethod": () => (/* binding */ api_markInvokeClassMethod),
+  "parseSdkVersion": () => (/* binding */ parseSdkVersion),
   "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"
@@ -650,6 +653,15 @@ function function_info_findCalleesForNew(lookupDefs) {
         .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
 }
 
+;// CONCATENATED MODULE: ./src/optimizer-types.ts
+var optimizer_types_StateNodeAttributes;
+(function (StateNodeAttributes) {
+    StateNodeAttributes[StateNodeAttributes["PUBLIC"] = 1] = "PUBLIC";
+    StateNodeAttributes[StateNodeAttributes["PROTECTED"] = 2] = "PROTECTED";
+    StateNodeAttributes[StateNodeAttributes["PRIVATE"] = 4] = "PRIVATE";
+    StateNodeAttributes[StateNodeAttributes["STATIC"] = 8] = "STATIC";
+})(optimizer_types_StateNodeAttributes || (optimizer_types_StateNodeAttributes = {}));
+
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
 
@@ -716,6 +728,7 @@ function variable_renamer_renameVariable(state, locals, declName) {
 
 
 
+
 // Note: Keep in sync with replaceInlinedSubExpression below
 function inliner_inlinableSubExpression(expr) {
     while (true) {
@@ -1035,6 +1048,12 @@ function processInlineBody(state, func, call, root, params) {
     state.inlining = true;
     let insertedVariableDecls = null;
     const replacements = new Set();
+    // lookup determines static-ness of the lookup context based on seeing
+    // a static FunctionDeclaration, but the FunctionDeclaration's stack
+    // doesn't include the FunctionDeclaration itself.
+    const stack = func.attributes & StateNodeAttributes.STATIC
+        ? func.stack.concat(func)
+        : func.stack;
     try {
         state.pre = (node) => {
             if (failed)
@@ -1084,7 +1103,7 @@ function processInlineBody(state, func, call, root, params) {
                 }
                 return null;
             }
-            const replacement = fixNodeScope(state, node, func.stack);
+            const replacement = fixNodeScope(state, node, stack);
             if (!replacement) {
                 failed = true;
                 inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
@@ -1139,7 +1158,7 @@ function processInlineBody(state, func, call, root, params) {
         delete state.inlining;
     }
 }
-function inliner_unused(expression, top) {
+function inliner_unused(state, expression, top) {
     const estmt = (expression) => withLoc({
         type: "ExpressionStatement",
         expression,
@@ -1153,19 +1172,19 @@ function inliner_unused(expression, top) {
             return [];
         case "BinaryExpression":
             if (expression.operator === "as") {
-                return inliner_unused(expression.left);
+                return inliner_unused(state, expression.left);
             }
-            return inliner_unused(expression.left).concat(inliner_unused(expression.right));
+            return inliner_unused(state, expression.left).concat(inliner_unused(state, expression.right));
         case "LogicalExpression": {
-            const right = inliner_unused(expression.right);
+            const right = inliner_unused(state, expression.right);
             if (!right.length)
-                return inliner_unused(expression.left);
+                return inliner_unused(state, expression.left);
             const consequent = withLoc({
                 type: "BlockStatement",
                 body: [estmt(expression.right)],
             }, expression.right);
             let alternate;
-            if (expression.operator == "||") {
+            if (expression.operator == "||" || expression.operator == "or") {
                 alternate = { ...consequent };
                 consequent.body = [];
             }
@@ -1179,10 +1198,10 @@ function inliner_unused(expression, top) {
             ];
         }
         case "ConditionalExpression": {
-            const consequentExprs = inliner_unused(expression.consequent);
-            const alternateExprs = inliner_unused(expression.alternate);
+            const consequentExprs = inliner_unused(state, expression.consequent);
+            const alternateExprs = inliner_unused(state, expression.alternate);
             if (!consequentExprs.length && !alternateExprs.length) {
-                return inliner_unused(expression.test);
+                return inliner_unused(state, expression.test);
             }
             return [
                 withLoc({
@@ -1200,17 +1219,24 @@ function inliner_unused(expression, top) {
             ];
         }
         case "UnaryExpression":
-            return inliner_unused(expression.argument);
+            return inliner_unused(state, expression.argument);
         case "MemberExpression":
             if (expression.computed) {
-                return inliner_unused(expression.object).concat(inliner_unused(expression.property));
+                return inliner_unused(state, expression.object).concat(inliner_unused(state, expression.property));
+            }
+            if ((state.sdkVersion || 0) < 4001007 &&
+                expression.object.type === "NewExpression") {
+                // prior to 4.1.7 top level new expressions were discarded,
+                // but (new X()).a was not. After 4.1.7, top level new is
+                // executed, but top level (new X()).a is an error.
+                break;
             }
-            return inliner_unused(expression.object);
+            return inliner_unused(state, expression.object);
         case "ArrayExpression":
-            return expression.elements.map((e) => inliner_unused(e)).flat(1);
+            return expression.elements.map((e) => inliner_unused(state, e)).flat(1);
         case "ObjectExpression":
             return expression.properties
-                .map((p) => inliner_unused(p.key).concat(inliner_unused(p.value)))
+                .map((p) => inliner_unused(state, p.key).concat(inliner_unused(state, p.value)))
                 .flat(1);
     }
     return top ? null : [estmt(expression)];
@@ -1370,7 +1396,7 @@ function inlineWithArgs(state, func, call, context) {
                 ];
             }
             else {
-                const side_exprs = inliner_unused(last.argument);
+                const side_exprs = inliner_unused(state, last.argument);
                 block.body.splice(block.body.length - 1, 1, ...side_exprs);
             }
         }
@@ -1505,7 +1531,7 @@ function pragma_checker_pragmaChecker(state, ast, diagnostics) {
         return;
     diagnostics = diagnostics
         ?.slice()
-        .sort((d1, d2) => d1.loc.start < d2.loc.start ? -1 : d1.loc.start == d2.loc.start ? 0 : 1);
+        .sort((d1, d2) => d1.loc.start.offset - d2.loc.start.offset);
     let diagIndex = 0;
     let index = -1;
     let comment;
@@ -1518,6 +1544,12 @@ function pragma_checker_pragmaChecker(state, ast, diagnostics) {
                 continue;
             const kind = match[1];
             let str = match[2];
+            const verCheck = checkCompilerVersion(str.replace(/\s.*/, ""), state.sdkVersion || 0);
+            if (verCheck === false)
+                continue;
+            if (verCheck === true) {
+                str = str.replace(/^\S+\s+/, "");
+            }
             matchers = [];
             while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
                 matchers.push({ kind, quote: match[1], needle: match[2] });
@@ -2126,7 +2158,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
 
 
@@ -3072,7 +3104,7 @@ function unused_exprs_cleanupUnusedVars(state, node) {
                         if (node.expression.type === "AssignmentExpression") {
                             if (node.expression.left.type === "Identifier" &&
                                 hasProperty(toRemove, node.expression.left.name)) {
-                                return unused(node.expression.right);
+                                return unused(state, node.expression.right);
                             }
                         }
                         else if (node.expression.type === "UpdateExpression" &&
@@ -3087,7 +3119,7 @@ function unused_exprs_cleanupUnusedVars(state, node) {
                             if (expr.type === "AssignmentExpression") {
                                 if (expr.left.type === "Identifier" &&
                                     hasProperty(toRemove, expr.left.name)) {
-                                    const rep = unused(expr.right);
+                                    const rep = unused(state, expr.right);
                                     if (!rep.length) {
                                         node.expressions.splice(i, 1);
                                     }
@@ -3117,8 +3149,18 @@ function unused_exprs_cleanupUnusedVars(state, node) {
                     const vdecl = decl.declarations[i];
                     const name = variableDeclarationName(vdecl.id);
                     if (hasProperty(toRemove, name)) {
-                        const rep = vdecl.init ? unused(vdecl.init) : [];
+                        const rep = vdecl.init ? unused(state, vdecl.init) : [];
                         if (rep.length) {
+                            if ((state.sdkVersion || 0) < 4001007 &&
+                                rep.find((s) => s.type === "ExpressionStatement" &&
+                                    (s.expression.type === "NewExpression" ||
+                                        (s.expression.type === "MemberExpression" &&
+                                            !s.expression.computed &&
+                                            s.expression.object.type === "NewExpression")))) {
+                                // prior to 4.1.7 vanilla new expressions were discarded,
+                                // so don't create top level new expressions.
+                                continue;
+                            }
                             if (parent.node.type === "ForStatement") {
                                 // declarations whose inits have side effects
                                 // can't be deleted from for statements.
@@ -3168,100 +3210,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
 
 
@@ -3350,7 +3298,8 @@ function collectClassInfo(state) {
         if (elm.hasInvoke && elm.decls) {
             Object.values(elm.decls).forEach((funcs) => {
                 funcs.forEach((f) => {
-                    if (f.type === "FunctionDeclaration" && !f.isStatic) {
+                    if (f.type === "FunctionDeclaration" &&
+                        !(f.attributes & StateNodeAttributes.STATIC)) {
                         markInvokeClassMethod(f);
                     }
                 });
@@ -3389,7 +3338,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 = {
@@ -3430,11 +3379,6 @@ async function analyze(fnMap, barrelList, config) {
                     const [scope] = state.stack.slice(-1);
                     scope.stack = state.stackClone().slice(0, -1);
                     if (scope.type == "FunctionDeclaration") {
-                        scope.isStatic =
-                            scope.stack.slice(-1)[0].type !== "ClassDeclaration" ||
-                                (scope.node.attrs &&
-                                    scope.node.attrs.access &&
-                                    scope.node.attrs.access.includes("static"));
                         if (markApi) {
                             node.body = null;
                             scope.info = getApiFunctionInfo(scope);
@@ -3457,7 +3401,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);
@@ -3473,17 +3417,53 @@ 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;
+    const compiler2DiagnosticType = config?.checkCompilerLookupRules !== "OFF"
+        ? config?.checkCompilerLookupRules || "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)
+                if (node.type === "BinaryExpression" && node.operator === "has") {
+                    // Its not an error to check whether a property exists...
                     return undefined;
+                }
                 const nodeStr = formatAst(node);
+                if (!error) {
+                    if (state.sdkVersion === 4001006 &&
+                        compiler2DiagnosticType &&
+                        node.type === "MemberExpression" &&
+                        (node.object.type === "Identifier" ||
+                            node.object.type === "MemberExpression") &&
+                        results.some((result) => {
+                            const parent = result.parent;
+                            if (!parent || parent.type !== "ClassDeclaration") {
+                                return false;
+                            }
+                            return result.results.some((sn) => {
+                                switch (sn.type) {
+                                    case "VariableDeclarator":
+                                    case "FunctionDeclaration":
+                                        return (sn.attributes &
+                                            (StateNodeAttributes.PRIVATE |
+                                                StateNodeAttributes.PROTECTED));
+                                }
+                                return false;
+                            });
+                        })) {
+                        diagnostic(state, node.loc, `The expression ${nodeStr} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
+                    }
+                    return undefined;
+                }
                 if (state.inType) {
                     if (!checkTypes || nodeStr.match(/^Void|Null$/)) {
                         return undefined;
@@ -3494,9 +3474,6 @@ async function analyze(fnMap, barrelList, config) {
             });
         });
     }
-    state.exposed = state.nextExposed;
-    state.nextExposed = {};
-    return state;
 }
 function compareLiteralLike(a, b) {
     while (a.type === "BinaryExpression")
@@ -3700,7 +3677,7 @@ function optimizeNode(state, node) {
                 left.value === null ||
                 ((left_type === "Number" || left_type === "Long") &&
                     (left.value === 0 || left.value === 0n));
-            if (falsy === (node.operator === "&&")) {
+            if (falsy === (node.operator === "&&" || node.operator === "and")) {
                 return left;
             }
             if (left_type !== "Boolean" &&
@@ -3710,10 +3687,12 @@ function optimizeNode(state, node) {
             }
             const [right, right_type] = getNodeValue(node.right);
             if (right && right_type === left_type) {
-                if (left_type === "Boolean" || node.operator === "||") {
+                if (left_type === "Boolean" ||
+                    node.operator === "||" ||
+                    node.operator === "or") {
                     return right;
                 }
-                if (node.operator !== "&&") {
+                if (node.operator !== "&&" && node.operator !== "and") {
                     throw new Error(`Unexpected operator "${node.operator}"`);
                 }
                 return { ...node, type: "BinaryExpression", operator: "&" };
@@ -3790,8 +3769,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 = {};
@@ -4191,6 +4170,36 @@ 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.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);
@@ -4273,7 +4282,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     }
                 }
                 else {
-                    const ret = unused(node.expression, true);
+                    const ret = unused(state, node.expression, true);
                     if (ret) {
                         return ret
                             .map((r) => replace(r, r))
@@ -4418,7 +4427,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) {
@@ -4426,6 +4435,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]);
         }
@@ -4541,6 +4553,322 @@ 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"];
+            }
+            case "ModuleDeclaration":
+                return ["body"];
+            case "ClassDeclaration":
+                return ["body", "superClass"];
+            case "FunctionDeclaration":
+                return ["params", "returnType", "body"];
+        }
+        return null;
+    };
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
+    delete state.pre;
+}
+
 ;// CONCATENATED MODULE: ./src/api.ts
 
 
@@ -4553,6 +4881,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
@@ -4562,35 +4892,62 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
  * undocumented. The same could be said of compiler.json and simulator.json,
  * but those are at least in a standard format.
  */
+function parseSdkVersion(version) {
+    if (!version)
+        return 0;
+    const match = version.match(/^(\d+)[._](\d+)[._](\d+)$/);
+    if (!match)
+        return 0;
+    return (parseInt(match[1], 10) * 1000000 +
+        parseInt(match[2], 10) * 1000 +
+        parseInt(match[3], 10));
+}
+function api_checkCompilerVersion(version, sdkVer) {
+    const match = version.match(/^(\d+[._]\d+[._]\d+)?([-_])?(\d+[._]\d+[._]\d+)?$/);
+    if (!match ||
+        (match[1] && match[3] && !match[2]) ||
+        (!match[1] && !match[3])) {
+        return undefined;
+    }
+    const v1 = parseSdkVersion(match[1]);
+    const v2 = parseSdkVersion(match[3]);
+    if (v1) {
+        if (v2) {
+            return v1 <= sdkVer && sdkVer <= v2;
+        }
+        if (match[2]) {
+            return v1 <= sdkVer;
+        }
+        return v1 === sdkVer;
+    }
+    return sdkVer <= v2;
+}
 // 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("")}}`;
+    if (state) {
+        state.sdk = sdk;
+        const match = state.sdk?.match(/-(\d+\.\d+\.\d+)/);
+        if (match) {
+            state.sdkVersion = parseSdkVersion(match[1]);
+        }
+    }
     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];
@@ -4633,6 +4990,26 @@ function api_isStateNode(node) {
 function api_variableDeclarationName(node) {
     return ("left" in node ? node.left : node).name;
 }
+function stateNodeAttrs(attrs) {
+    return attrs && attrs.access
+        ? attrs.access.reduce((cur, attr) => {
+            switch (attr) {
+                case "static":
+                    return cur | optimizer_types_StateNodeAttributes.STATIC;
+                case "public":
+                    return cur | optimizer_types_StateNodeAttributes.PUBLIC;
+                case "protected":
+                    return cur | optimizer_types_StateNodeAttributes.PROTECTED;
+                case "hidden":
+                    return cur | optimizer_types_StateNodeAttributes.PROTECTED;
+                case "private":
+                    return cur | optimizer_types_StateNodeAttributes.PRIVATE;
+                default:
+                    return cur;
+            }
+        }, 0)
+        : 0;
+}
 function lookupToStateNodeDecls(results) {
     return results.reduce((result, current) => current.results.length
         ? result
@@ -4640,7 +5017,7 @@ function lookupToStateNodeDecls(results) {
             : current.results
         : result, null);
 }
-function checkOne(state, ns, decls, node, isStatic) {
+function checkOne(state, ns, decls, node) {
     // follow the superchain, looking up node in each class
     const superChain = (cls) => {
         if (!cls.superClass || cls.superClass === true) {
@@ -4655,7 +5032,7 @@ function checkOne(state, ns, decls, node, isStatic) {
         }, null);
     };
     const lookupInContext = (ns) => {
-        const [, lkup] = lookup(state, decls, node, null, ns.stack);
+        const [, lkup] = lookup(state, decls, node, null, ns.stack, false, true);
         return lkup && lookupToStateNodeDecls(lkup);
     };
     // follow the superchain, looking up node in each class's scope
@@ -4677,10 +5054,7 @@ function checkOne(state, ns, decls, node, isStatic) {
     }
     switch (ns.type) {
         case "ClassDeclaration":
-            if (!isStatic) {
-                return superChain(ns) || superChainScopes(ns) || false;
-            }
-        // fall through
+            return superChain(ns) || superChainScopes(ns) || false;
         case "ModuleDeclaration":
             return lookupInContext(ns) || false;
     }
@@ -4728,7 +5102,7 @@ function api_isLookupCandidate(node) {
  *  - [false, false] - if the lookup fails, but its not an error because its not the kind of expression we can lookup
  *  - [null, null] - if the lookup fails unexpectedly.
  */
-function lookup(state, decls, node, name, maybeStack, nonlocal) {
+function lookup(state, decls, node, name, maybeStack, nonlocal, ignoreImports) {
     const stack = maybeStack || state.stack;
     switch (node.type) {
         case "MemberExpression": {
@@ -4737,7 +5111,7 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
                 break;
             let result;
             if (node.object.type === "ThisExpression") {
-                [, result] = lookup(state, decls, node.property, name, stack, true);
+                [, result] = lookup(state, decls, node.property, name, stack, true, true);
             }
             else {
                 const [, results] = lookup(state, decls, node.object, name, stack, false);
@@ -4751,7 +5125,7 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
                         if (!api_isStateNode(module)) {
                             return null;
                         }
-                        const res = checkOne(state, module, decls, property, false);
+                        const res = checkOne(state, module, decls, property);
                         return res ? { parent: module, results: res } : null;
                     })
                         .filter((r) => r != null);
@@ -4760,14 +5134,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.
@@ -4781,7 +5152,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) {
@@ -4797,30 +5168,66 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
                 return [name || node.name, [{ parent: null, results: [stack[0]] }]];
             }
             let inStatic = false;
-            let checkedImports = false;
+            let checkedImports = ignoreImports;
+            let imports = null;
             for (let i = stack.length; i--;) {
                 const si = stack[i];
                 switch (si.type) {
                     case "ClassDeclaration":
+                        if (inStatic && state.config?.enforceStatic != "NO") {
+                            inStatic = false;
+                            if (ast_hasProperty(si.decls, node.name)) {
+                                const r = si.decls[node.name].filter((s) => {
+                                    switch (s.type) {
+                                        case "FunctionDeclaration":
+                                        case "VariableDeclarator":
+                                        case "ClassDeclaration":
+                                            // In theory we should include EnumStringMember here too, but
+                                            // without adding an attributes field to EnumStringMember,
+                                            // or turning it into a StateNodeDecl, we don't know whether
+                                            // its static or not. But thats ok, because the optimizer
+                                            // will replace its use with its value, so the optimized
+                                            // code *will* work anyway.
+                                            return s.attributes & optimizer_types_StateNodeAttributes.STATIC;
+                                        default:
+                                            return true;
+                                    }
+                                });
+                                if (r.length) {
+                                    return [name || node.name, [{ parent: si, results: r }]];
+                                }
+                            }
+                            continue;
+                        }
+                    // fall through
                     case "ModuleDeclaration":
                     case "Program":
                         if (!checkedImports) {
                             checkedImports = true;
-                            const results = findUsingForNode(state, stack, i, node, decls === "type_decls");
+                            const results = findUsingForNode(state, stack, i, node);
                             if (results) {
-                                return [name || node.name, [{ parent: si, results }]];
+                                if (Array.isArray(results)) {
+                                    if (!imports)
+                                        imports = results;
+                                }
+                                else {
+                                    return [
+                                        name || node.name,
+                                        [{ parent: si, results: [results] }],
+                                    ];
+                                }
                             }
                         }
                         break;
                     case "FunctionDeclaration":
-                        inStatic = si.isStatic === true;
+                        inStatic = !!(si.attributes & optimizer_types_StateNodeAttributes.STATIC);
                     // fall through
                     default:
                         if (nonlocal)
                             continue;
                         break;
                 }
-                const results = checkOne(state, si, decls, node, inStatic);
+                const results = checkOne(state, si, decls, node);
                 if (results) {
                     return [name || node.name, [{ parent: si, results }]];
                 }
@@ -4828,6 +5235,31 @@ function lookup(state, decls, node, name, maybeStack, nonlocal) {
                     break;
                 }
             }
+            if (imports) {
+                if (imports.length > 1) {
+                    if (state.config?.checkInvalidSymbols !== "OFF") {
+                        inliner_diagnostic(state, node.loc, `${api_formatAst(node)} is ambiguous and exists in multiple imported modules [${imports
+                            .map(({ name }) => name)
+                            .join(", ")}]`, state.config?.checkInvalidSymbols || "WARNING");
+                    }
+                    else if (decls !== "type_decls" &&
+                        state.lookupRules === "COMPILER1") {
+                        return [null, null];
+                    }
+                    return [name || node.name, imports.map((d) => d.decls)];
+                }
+                if (imports.length == 1) {
+                    if (decls !== "type_decls") {
+                        if (state.config?.checkCompilerLookupRules !== "OFF") {
+                            inliner_diagnostic(state, node.loc, `${api_formatAst(node)} will only be found when compiled with compiler2 at -O1 or above`, state.config?.checkCompilerLookupRules || "WARNING");
+                        }
+                        else if (state.lookupRules === "COMPILER1") {
+                            return [null, null];
+                        }
+                    }
+                    return [name || node.name, [imports[0].decls]];
+                }
+            }
             return [null, null];
         }
     }
@@ -4841,9 +5273,27 @@ function api_collectNamespaces(ast, stateIn) {
         state.index = {};
     if (!state.stack) {
         state.stack = [
-            { type: "Program", name: "$", fullName: "$", node: undefined },
+            {
+                type: "Program",
+                name: "$",
+                fullName: "$",
+                node: undefined,
+                attributes: 0,
+            },
         ];
     }
+    if (!state.lookupRules) {
+        const rules = state?.config?.compilerLookupRules || "DEFAULT";
+        if (rules !== "COMPILER1" && rules !== "COMPILER2") {
+            const match = state.sdk?.match(/-(\d+\.\d+\.\d+).(compiler2beta)?/i);
+            if (match && (match[2] || parseSdkVersion(match[1]) >= 4001006)) {
+                state.lookupRules = "COMPILER2";
+            }
+            else {
+                state.lookupRules = "COMPILER1";
+            }
+        }
+    }
     state.removeNodeComments = (node, ast) => {
         if (node.start && node.end && ast.comments && ast.comments.length) {
             let low = 0, high = ast.comments.length;
@@ -4938,6 +5388,7 @@ function api_collectNamespaces(ast, stateIn) {
                             name: undefined,
                             node: node.body,
                             decls: { [id.name]: [id] },
+                            attributes: 0,
                         });
                     }
                     break;
@@ -4948,6 +5399,7 @@ function api_collectNamespaces(ast, stateIn) {
                             fullName: undefined,
                             name: undefined,
                             node: node,
+                            attributes: 0,
                         });
                     }
                     break;
@@ -4975,6 +5427,9 @@ function api_collectNamespaces(ast, stateIn) {
                         name,
                         fullName,
                         node,
+                        attributes: node.type === "BlockStatement"
+                            ? 0
+                            : stateNodeAttrs(node.attrs),
                     };
                     state.stack.push(elm);
                     if (name) {
@@ -5001,9 +5456,6 @@ function api_collectNamespaces(ast, stateIn) {
                         parent.decls[name].push(elm);
                         if (node.type == "ModuleDeclaration" ||
                             node.type == "ClassDeclaration") {
-                            // Inject the class/module name into itself,
-                            // so you can say Graphics.Graphics.Graphics.COLOR_RED
-                            elm.decls = { [name]: [elm] };
                             if (!parent.type_decls)
                                 parent.type_decls = {};
                             if (!ast_hasProperty(parent.type_decls, name)) {
@@ -5045,6 +5497,7 @@ function api_collectNamespaces(ast, stateIn) {
                             node,
                             name,
                             fullName: parent.fullName + "." + name,
+                            attributes: stateNodeAttrs(node.attrs),
                         });
                     break;
                 }
@@ -5063,12 +5516,13 @@ function api_collectNamespaces(ast, stateIn) {
                             return;
                         }
                         decl.kind = node.kind;
-                        (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], {
+                        decls[name].push({
                             type: "VariableDeclarator",
                             node: decl,
                             name,
                             fullName: parent.fullName + "." + name,
                             stack,
+                            attributes: stateNodeAttrs(node.attrs),
                         });
                         if (node.kind == "const") {
                             if (!ast_hasProperty(state.index, name)) {
@@ -5293,27 +5747,32 @@ function findUsing(state, stack, using) {
     }
     return null;
 }
-function findUsingForNode(state, stack, i, node, isType) {
+function findUsingForNode(state, stack, i, node) {
+    let imports = null;
     while (i >= 0) {
         const si = stack[i--];
         if (ast_hasProperty(si.usings, node.name)) {
             const using = si.usings[node.name];
-            const module = findUsing(state, stack, using);
-            return module && [module];
+            return findUsing(state, stack, using);
         }
-        if (si.imports && isType) {
+        if (si.imports) {
             for (let j = si.imports.length; j--;) {
                 const using = si.imports[j];
                 const module = findUsing(state, stack, using);
                 if (module) {
                     if (ast_hasProperty(module.type_decls, node.name)) {
-                        return module.type_decls[node.name];
+                        if (!imports)
+                            imports = [];
+                        imports.push({
+                            name: `${module.fullName}.${node.name}`,
+                            decls: { parent: si, results: module.type_decls[node.name] },
+                        });
                     }
                 }
             }
         }
     }
-    return null;
+    return imports;
 }
 const invokeInfo = {};
 const toyboxFnInfo = {};