@markw65/monkeyc-optimizer 1.0.39 → 1.0.40

package/build/api.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visitorNode});
+0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -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,6 +268,7 @@ __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),
@@ -651,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
 
 
@@ -717,6 +728,7 @@ function variable_renamer_renameVariable(state, locals, declName) {
 
 
 
+
 // Note: Keep in sync with replaceInlinedSubExpression below
 function inliner_inlinableSubExpression(expr) {
     while (true) {
@@ -1036,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)
@@ -1085,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}'`);
@@ -1140,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,
@@ -1154,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 = [];
             }
@@ -1180,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({
@@ -1201,20 +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 (expression.object.type === "NewExpression") {
+            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)];
@@ -1374,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);
             }
         }
@@ -1509,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;
@@ -1522,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] });
@@ -3076,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" &&
@@ -3091,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);
                                     }
@@ -3121,13 +3149,16 @@ 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 (rep.find((s) => s.type === "ExpressionStatement" &&
-                                (s.expression.type === "NewExpression" ||
-                                    (s.expression.type === "MemberExpression" &&
-                                        !s.expression.computed &&
-                                        s.expression.object.type === "NewExpression")))) {
+                            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") {
@@ -3191,6 +3222,7 @@ function unused_exprs_cleanupUnusedVars(state, node) {
 
 
 
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -3266,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);
                     }
                 });
@@ -3346,11 +3379,6 @@ async function analyze(fnMap, resourcesMap, 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);
@@ -3397,18 +3425,45 @@ 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(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 (!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;
@@ -3622,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" &&
@@ -3632,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: "&" };
@@ -4125,7 +4182,6 @@ async function optimizeMonkeyC(fnMap, resourcesMap, config) {
                         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
@@ -4226,7 +4282,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, config) {
                     }
                 }
                 else {
-                    const ret = unused(node.expression, true);
+                    const ret = unused(state, node.expression, true);
                     if (ret) {
                         return ret
                             .map((r) => replace(r, r))
@@ -4800,6 +4856,12 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
                 }
                 return ["returnType"];
             }
+            case "ModuleDeclaration":
+                return ["body"];
+            case "ClassDeclaration":
+                return ["body", "superClass"];
+            case "FunctionDeclaration":
+                return ["params", "returnType", "body"];
         }
         return null;
     };
@@ -4820,6 +4882,7 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
 
 
 
+
 /*
  * 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
@@ -4829,11 +4892,48 @@ function visitor_visitReferences(state, ast, name, defn, callback) {
  * 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, 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)();
+    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")
@@ -4890,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
@@ -4897,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) {
@@ -4912,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
@@ -4934,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;
     }
@@ -4985,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": {
@@ -4994,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);
@@ -5008,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);
@@ -5051,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 }]];
                 }
@@ -5082,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];
         }
     }
@@ -5095,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;
@@ -5192,6 +5388,7 @@ function api_collectNamespaces(ast, stateIn) {
                             name: undefined,
                             node: node.body,
                             decls: { [id.name]: [id] },
+                            attributes: 0,
                         });
                     }
                     break;
@@ -5202,6 +5399,7 @@ function api_collectNamespaces(ast, stateIn) {
                             fullName: undefined,
                             name: undefined,
                             node: node,
+                            attributes: 0,
                         });
                     }
                     break;
@@ -5229,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) {
@@ -5255,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)) {
@@ -5299,6 +5497,7 @@ function api_collectNamespaces(ast, stateIn) {
                             node,
                             name,
                             fullName: parent.fullName + "." + name,
+                            attributes: stateNodeAttrs(node.attrs),
                         });
                     break;
                 }
@@ -5317,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)) {
@@ -5547,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 = {};