@markw65/monkeyc-optimizer 1.0.41 → 1.0.43

package/build/api.cjs

@@ -1,8 +1,8 @@
-0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visitorNode});
+0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 789:
+/***/ 2789:
 /***/ ((module) => {
 
 /**
@@ -273,6 +273,7 @@ __webpack_require__.d(__webpack_exports__, {
   "traverseAst": () => (/* reexport */ ast_traverseAst),
   "variableDeclarationName": () => (/* binding */ api_variableDeclarationName),
   "visitReferences": () => (/* reexport */ visitor_visitReferences),
+  "visit_resources": () => (/* reexport */ visit_resources),
   "visitorNode": () => (/* reexport */ visitorNode)
 });
 
@@ -465,7 +466,13 @@ function ast_withLoc(node, start, end) {
             node.end = start.end;
         node.loc = { ...(node.loc || start.loc), start: start.loc.start };
     }
-    if (end && end.loc) {
+    if (end === false) {
+        if (node.loc) {
+            node.loc.end = node.loc.start;
+            node.end = node.start;
+        }
+    }
+    else if (end && end.loc) {
         node.end = end.end;
         node.loc = { ...(node.loc || end.loc), end: end.loc.end };
     }
@@ -828,6 +835,12 @@ function getArgSafety(state, func, args, requireAll) {
     let allSafe = true;
     if (!args.every((arg, i) => {
         switch (arg.type) {
+            case "UnaryExpression":
+                if (arg.operator === ":") {
+                    safeArgs.push(true);
+                    return true;
+                }
+                break;
             case "Literal":
                 safeArgs.push(true);
                 return true;
@@ -1407,7 +1420,16 @@ function inlineWithArgs(state, func, call, context) {
     withLocDeep(body, context, context, true);
     return body;
 }
-function inliner_inlineFunction(state, func, call, context) {
+function isTypecheckArg(node, arg) {
+    return (node.type === "CallExpression" &&
+        node.callee.type === "Identifier" &&
+        node.callee.name === ":typecheck" &&
+        (arg === null ||
+            (node.arguments.length === 1 &&
+                node.arguments[0].type === "Literal" &&
+                node.arguments[0].value === arg)));
+}
+function inlineFunctionHelper(state, func, call, context) {
     if (context) {
         return inlineWithArgs(state, func, call, context);
     }
@@ -1418,6 +1440,33 @@ function inliner_inlineFunction(state, func, call, context) {
     state.localsStack[state.localsStack.length - 1].map = map;
     return ret && withLocDeep(ret, call, call, true);
 }
+function inliner_inlineFunction(state, func, call, context) {
+    const ret = inlineFunctionHelper(state, func, call, context);
+    if (!ret)
+        return ret;
+    const typecheckFalse = func.node.attrs?.attributes?.elements.find((attr) => isTypecheckArg(attr, false));
+    if (!typecheckFalse) {
+        return ret;
+    }
+    const callerSn = state.stack.find((sn) => sn.type === "FunctionDeclaration");
+    if (!callerSn) {
+        return ret;
+    }
+    const caller = callerSn.node;
+    if (!caller.attrs) {
+        caller.attrs = withLoc({
+            type: "AttributeList",
+        }, caller, false);
+    }
+    if (!caller.attrs.attributes) {
+        caller.attrs.attributes = withLoc({ type: "Attributes", elements: [] }, caller.attrs, false);
+    }
+    if (caller.attrs.attributes.elements.find((attr) => isTypecheckArg(attr, null))) {
+        return ret;
+    }
+    caller.attrs.attributes.elements.unshift(withLocDeep({ ...typecheckFalse }, caller.attrs, false));
+    return ret;
+}
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
         node = {
@@ -2158,7 +2207,7 @@ function getPreOrder(head) {
 }
 
 // EXTERNAL MODULE: ./node_modules/priorityqueuejs/index.js
-var priorityqueuejs = __webpack_require__(789);
+var priorityqueuejs = __webpack_require__(2789);
 ;// CONCATENATED MODULE: ./src/pre.ts
 
 
@@ -3338,7 +3387,7 @@ function getFileASTs(fnMap) {
         return ok;
     }, true));
 }
-async function analyze(fnMap, resourcesMap, config) {
+async function analyze(fnMap, resourcesMap, manifestXML, config) {
     let hasTests = false;
     let markApi = true;
     const preState = {
@@ -3401,7 +3450,7 @@ async function analyze(fnMap, resourcesMap, config) {
             return null;
         },
     };
-    await getApiMapping(preState, resourcesMap);
+    await getApiMapping(preState, resourcesMap, manifestXML);
     markApi = false;
     const state = preState;
     await getFileASTs(fnMap);
@@ -3431,13 +3480,12 @@ function reportMissingSymbols(state, config) {
     if (diagnosticType &&
         !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
         const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
-        Object.entries(state.fnMap).forEach(([, v]) => {
-            visitReferences(state, v.ast, null, false, (node, results, error) => {
+        const report = (ast) => {
+            visitReferences(state, ast, null, false, (node, results, 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 &&
@@ -3460,19 +3508,22 @@ function reportMissingSymbols(state, config) {
                                 return false;
                             });
                         })) {
-                        diagnostic(state, node.loc, `The expression ${nodeStr} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
+                        diagnostic(state, node.loc, `The expression ${formatAst(node)} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
                     }
                     return undefined;
                 }
+                let nodeStr;
                 if (state.inType) {
-                    if (!checkTypes || nodeStr.match(/^Void|Null$/)) {
+                    if (!checkTypes || (nodeStr = formatAst(node)).match(/^Void|Null$/)) {
                         return undefined;
                     }
                 }
-                diagnostic(state, node.loc, `Undefined symbol ${nodeStr}`, diagnosticType);
+                diagnostic(state, node.loc, `Undefined symbol ${nodeStr || formatAst(node)}`, diagnosticType);
                 return false;
             });
-        });
+        };
+        Object.values(state.fnMap).forEach((v) => v.ast && report(v.ast));
+        state.rezAst && report(state.rezAst);
     }
 }
 function compareLiteralLike(a, b) {
@@ -3769,8 +3820,8 @@ function markFunctionCalled(state, func) {
     }
     pushUnique(state.calledFunctions[func.id.name], func);
 }
-async function optimizeMonkeyC(fnMap, resourcesMap, config) {
-    const state = (await analyze(fnMap, resourcesMap, config));
+async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
+    const state = (await analyze(fnMap, resourcesMap, manifestXML, config));
     state.localsStack = [{}];
     state.calledFunctions = {};
     state.usedByName = {};
@@ -4560,198 +4611,399 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
  * 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) {
+function visit_resources(elements, parent, v) {
+    const visitor = typeof v === "function"
+        ? {
+            visit: v,
+        }
+        : v;
+    const pname = parent ? parent.name : null;
+    const error = (e) => visitor.error && visitor.error(e, pname);
+    const visit = (e, module) => visitor.visit && visitor.visit(e, module, parent);
     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;
+        if (visitor.pre ? visitor.pre(e) === false : e.type !== "element") {
+            return;
+        }
+        if (e.type == "element") {
+            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);
+                        break;
+                    }
+                    e.children && visit_resources(e.children, e, visitor);
+                    break;
+                // 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 (pname && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit_resources(external_sdk_util_cjs_namespaceObject.xmlUtil.elementKids(e), e, visitor);
+                    break;
+                // 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 (pname !== "strings" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Strings");
+                    break;
+                case "font":
+                    if (pname !== "fonts" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Fonts");
+                    break;
+                case "animation":
+                    if (pname !== "animations" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Drawables");
+                    break;
+                case "menu":
+                case "menu2":
+                case "checkbox-menu":
+                case "action-menu":
+                    if (pname && pname !== "menus" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Menus");
+                    break;
+                case "bitmap":
+                    if (pname !== "bitmaps" &&
+                        pname !== "drawables" &&
+                        pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Drawables");
+                    break;
+                case "layout":
+                    if (pname && pname !== "layouts" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Layouts");
+                    break;
+                case "drawable-list":
+                    if (pname && pname !== "drawables" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Drawables");
+                    break;
+                case "property":
+                    if (pname !== "properties" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Properties");
+                    break;
+                case "setting":
+                    if (pname !== "settings" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Settings");
+                    break;
+                case "group":
+                    if (pname !== "settings" /* && pname !== "resources" */) {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "Settings");
+                    break;
+                case "fitField":
+                    if (pname !== "fitContributions" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "FitFields");
+                    break;
+                case "jsonData":
+                    if (pname && pname != "jsonDataResources" && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, "JsonData");
+                    break;
+                case "build":
+                    if (pname && pname !== "resources") {
+                        error(e);
+                        break;
+                    }
+                    visit(e, null);
+                    break;
+            }
         }
+        if (visitor.post)
+            visitor.post(e);
     });
 }
-function add_resources_to_ast(ast, resources) {
+function add_resources_to_ast(ast, resources, manifestXML) {
+    const modules = {
+        Drawables: true,
+        Fonts: true,
+        JsonData: true,
+        Layouts: true,
+        Menus: true,
+        Strings: true,
+        Properties: false,
+        Settings: false,
+        FitFields: false,
+    };
+    const outerLoc = ast.loc && { ...ast.loc };
+    const makeModule = (m) => ({
+        type: "ModuleDeclaration",
+        id: { type: "Identifier", name: m },
+        body: { type: "BlockStatement", body: [] },
+        loc: outerLoc,
+    });
+    const makeImport = (type, module, as) => {
+        const id = makeScopedName(module);
+        return type === "Using" && as
+            ? { type, id, as: makeIdentifier(as) }
+            : { type, id };
+    };
+    ast.body.push(makeImport("ImportModule", "Toybox.Lang"), makeImport("Using", "Toybox.WatchUi"), makeImport("Using", "Toybox.WatchUi", "Ui"), makeImport("Using", "Toybox.Graphics"), makeImport("Using", "Toybox.Graphics", "Gfx"));
     Object.entries(resources).forEach(([barrel, resourceMap]) => {
-        const rezModules = {
-            Drawables: [],
-            Fonts: [],
-            JsonData: [],
-            Layouts: [],
-            Menus: [],
-            Properties: [],
-            Strings: [],
-        };
+        let body = ast.body;
+        if (barrel !== "") {
+            const module = makeModule(barrel);
+            body.push(module);
+            body = module.body.body;
+        }
+        const rez = makeModule("Rez");
+        body.push(rez);
+        const hiddenRez = makeModule("*Rez*");
+        rez.body.body.push(hiddenRez);
+        if (barrel === "" &&
+            manifestXML &&
+            manifestXML.body instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Nodes) {
+            manifestXML.body
+                .children("iq:application")
+                .elements.forEach((e) => add_one_resource(rez, e));
+        }
+        const rezModules = Object.fromEntries(Object.entries(modules).map(([moduleName, isPublic]) => {
+            const module = makeModule(moduleName);
+            (isPublic ? rez : hiddenRez).body.body.push(module);
+            return [moduleName, module];
+        }));
         Object.values(resourceMap).forEach((rez) => {
-            if (!rez || !(rez instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Document))
+            if (!rez || rez.body instanceof Error)
                 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 module = rezModules[s];
+                add_one_resource(module, e);
             });
         });
-        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;
+    });
+}
+function makeIdentifier(name, loc) {
+    return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+    return wrap({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+    }, object.loc && locRange(object.loc, property.loc));
+}
+function makeScopedName(dotted, l) {
+    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+    return dotted.split(".").reduce(({ cur, offset }, next) => {
+        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
+        if (!cur) {
+            cur = id;
         }
-        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,
-                }));
-        });
+        else {
+            cur = makeMemberExpression(cur, id);
+        }
+        offset += next.length + 1;
+        return { cur, offset };
+    }, { cur: null, offset: 0 }).cur;
+}
+function visit_resource_refs(e) {
+    const result = [];
+    const stringToScopedName = (element, id, dotted, l) => {
+        const match = dotted.match(/^(@)?([\w_$]+\s*\.\s*)*[\w_$]+$/);
+        if (!match)
+            return;
+        let offset = 0;
+        if (match[1]) {
+            offset = 1;
+        }
+        else if ((element === "drawable" && id === "class") ||
+            (element === "iq:application" && id === "entry")) {
+            // nothing to do
+        }
+        else {
+            return;
+        }
+        const dn = makeScopedName(dotted.substring(offset), adjustLoc(l, offset, 0));
+        if (dn)
+            result.push(dn);
+    };
+    visit_resources([e], null, {
+        pre(node) {
+            if (node.type === "element") {
+                Object.values(node.attr).forEach((attr) => {
+                    if (!attr || !attr.value.loc)
+                        return;
+                    const loc = adjustLoc(attr.value.loc);
+                    attr &&
+                        stringToScopedName(node.name, attr.name.value, attr.value.value, loc);
+                });
+                if (node.children &&
+                    node.children.length === 1 &&
+                    node.children[0].type === "chardata") {
+                    stringToScopedName(node.name, null, node.children[0].value, node.children[0].loc);
+                }
+                return;
+            }
+        },
     });
+    return result;
+}
+function wrap(node, loc) {
+    if (loc) {
+        node.loc = loc;
+        node.start = loc.start.offset;
+        node.end = loc.end.offset;
+    }
+    return node;
+}
+function locRange(start, end) {
+    return {
+        source: start.source || end.source,
+        start: start.start,
+        end: end.end,
+    };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+    /* Attributes are quoted, so skip the quotes */
+    return {
+        source: loc.source,
+        start: {
+            offset: loc.start.offset + start,
+            line: loc.start.line,
+            column: loc.start.column + start,
+        },
+        end: {
+            offset: loc.end.offset + end,
+            line: loc.end.line,
+            column: loc.end.column + end,
+        },
+    };
+}
+function add_one_resource(module, e) {
+    let id;
+    let func;
+    const varDecl = () => {
+        const loc = id && adjustLoc(id.value.loc);
+        return wrap({
+            type: "VariableDeclaration",
+            declarations: [
+                wrap({
+                    type: "VariableDeclarator",
+                    kind: "var",
+                    id: makeIdentifier(id ? id.value.value : "*invalid*", loc),
+                    init,
+                }, loc),
+            ],
+            kind: "var",
+        }, loc);
+    };
+    const classDecl = (parent) => {
+        if (!id)
+            return null;
+        const loc = id.value.loc;
+        const items = init
+            ? [{ type: "ClassElement", item: varDecl(), loc }]
+            : [];
+        return {
+            type: "ClassDeclaration",
+            body: { type: "ClassBody", body: items, loc },
+            id: makeIdentifier(id.value.value, loc),
+            superClass: makeScopedName(parent),
+            loc,
+        };
+    };
+    switch (e.name) {
+        case "font":
+        case "string":
+        case "jsonData":
+        case "animation":
+        case "bitmap":
+        case "layout":
+        case "drawable-list":
+        case "property":
+        case "fitField":
+            id = e.attr.id;
+            func = varDecl;
+            break;
+        case "menu":
+            id = e.attr.id;
+            func = () => classDecl("Ui.Menu");
+            break;
+        case "menu2":
+            id = e.attr.id;
+            func = () => classDecl("Ui.Menu2");
+            break;
+        case "checkbox-menu":
+            id = e.attr.id;
+            func = () => classDecl("Ui.CheckboxMenu");
+            break;
+        case "action-menu":
+            id = e.attr.id;
+            func = () => classDecl("Ui.Menu2");
+            break;
+        case "setting":
+        case "group":
+            func = varDecl;
+            break;
+        case "iq:application":
+            func = varDecl;
+            break;
+    }
+    if (!func)
+        return;
+    const elements = visit_resource_refs(e);
+    const init = elements.length
+        ? { type: "ArrayExpression", elements }
+        : undefined;
+    if (!id) {
+        if (!init)
+            return;
+    }
+    const item = func();
+    if (item) {
+        module.body.body.push(item);
+    }
 }
 
 ;// CONCATENATED MODULE: ./src/visitor.ts
@@ -4761,7 +5013,10 @@ function visitorNode(node) {
         return node;
     }
     if (node.type === "MemberExpression") {
-        return node.property;
+        return node.property.type === "UnaryExpression" &&
+            node.property.operator === ":"
+            ? node.property.argument
+            : node.property;
     }
     if (node.type === "BinaryExpression" &&
         node.operator === "has" &&
@@ -4771,7 +5026,7 @@ function visitorNode(node) {
     }
     return node;
 }
-function visitor_visitReferences(state, ast, name, defn, callback, includeDefs = false) {
+function visitor_visitReferences(state, ast, name, defn, callback, includeDefs = false, filter = null) {
     const checkResults = ([name, results], node) => {
         if (name && results) {
             if (!defn || (0,external_api_cjs_namespaceObject.sameLookupResult)(results, defn)) {
@@ -4788,6 +5043,8 @@ function visitor_visitReferences(state, ast, name, defn, callback, includeDefs =
         return null;
     };
     state.pre = (node) => {
+        if (filter && !filter(node))
+            return [];
         switch (node.type) {
             case "AttributeList":
                 return [];
@@ -4948,7 +5205,7 @@ function api_checkCompilerVersion(version, sdkVer) {
     return sdkVer <= v2;
 }
 // Extract all enum values from api.mir
-async function api_getApiMapping(state, resourcesMap) {
+async function api_getApiMapping(state, resourcesMap, manifestXML) {
     // 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)();
@@ -4962,17 +5219,25 @@ async function api_getApiMapping(state, resourcesMap) {
     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 ");
     try {
         const ast = parser.parse(api, null, {
             filepath: "api.mir",
         });
         if (resourcesMap) {
-            add_resources_to_ast(ast, resourcesMap);
+            const rezAst = state
+                ? state.rezAst || { type: "Program", body: [] }
+                : ast;
+            add_resources_to_ast(rezAst, resourcesMap, manifestXML);
+            if (state) {
+                state.rezAst = rezAst;
+                state.manifestXML = manifestXML;
+            }
         }
         const result = api_collectNamespaces(ast, state);
+        if (state && state.rezAst) {
+            api_collectNamespaces(state.rezAst, state);
+        }
         negativeFixups.forEach((fixup) => {
             const vs = fixup.split(".").reduce((state, part) => {
                 const decls = api_isStateNode(state) && state.decls?.[part];
@@ -5597,6 +5862,9 @@ function api_collectNamespaces(ast, stateIn) {
                             throw new Error("Unexpected enum initializer");
                         }
                         if (init != m.init) {
+                            if (m.init.enumType) {
+                                init.enumType = m.init.enumType;
+                            }
                             m.init = init;
                         }
                         if (init.type == "Literal" &&