@markw65/monkeyc-optimizer 1.1.75 → 1.1.77

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to the "monkeyc-optimizer" package will be documented in this file.
 
+### 1.1.77
+
+- Fix an infinite recursion issue with nested classes
+- Fix a problem analyzing 'instanceof Boolean'
+
+### 1.1.76
+
+- Fix member expression lookup when base type is exact
+- Fix path-resolution inside locals in jungle files
+
 ### 1.1.75
 
 - Fix issues using personality files from barrels

package/build/api.cjs

@@ -18,55 +18,57 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  checkCompilerVersion: () => import_chunk_7GXXJDR3.checkCompilerVersion,
-  collectNamespaces: () => import_chunk_7GXXJDR3.collectNamespaces,
-  createDocumentationMap: () => import_chunk_7GXXJDR3.createDocumentationMap,
-  diagnostic: () => import_chunk_7GXXJDR3.diagnostic,
-  diagnosticHelper: () => import_chunk_7GXXJDR3.diagnosticHelper,
-  findNamesInScope: () => import_chunk_7GXXJDR3.findNamesInScope,
-  findUsingForNode: () => import_chunk_7GXXJDR3.findUsingForNode,
-  formatAst: () => import_chunk_7GXXJDR3.formatAst,
-  formatAstLongLines: () => import_chunk_7GXXJDR3.formatAstLongLines,
-  formatScopedName: () => import_chunk_7GXXJDR3.formatScopedName,
-  getApiFunctionInfo: () => import_chunk_7GXXJDR3.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_7GXXJDR3.getApiMapping,
-  getSuperClasses: () => import_chunk_7GXXJDR3.getSuperClasses,
-  handleImportUsing: () => import_chunk_7GXXJDR3.handleImportUsing,
+  checkCompilerVersion: () => import_chunk_G6WICLD7.checkCompilerVersion,
+  collectNamespaces: () => import_chunk_G6WICLD7.collectNamespaces,
+  createDocumentationMap: () => import_chunk_G6WICLD7.createDocumentationMap,
+  declKey: () => import_chunk_G6WICLD7.declKey,
+  diagnostic: () => import_chunk_G6WICLD7.diagnostic,
+  diagnosticHelper: () => import_chunk_G6WICLD7.diagnosticHelper,
+  findNamesInScope: () => import_chunk_G6WICLD7.findNamesInScope,
+  findUsingForNode: () => import_chunk_G6WICLD7.findUsingForNode,
+  formatAst: () => import_chunk_G6WICLD7.formatAst,
+  formatAstLongLines: () => import_chunk_G6WICLD7.formatAstLongLines,
+  formatScopedName: () => import_chunk_G6WICLD7.formatScopedName,
+  getApiFunctionInfo: () => import_chunk_G6WICLD7.getApiFunctionInfo,
+  getApiMapping: () => import_chunk_G6WICLD7.getApiMapping,
+  getSuperClasses: () => import_chunk_G6WICLD7.getSuperClasses,
+  handleImportUsing: () => import_chunk_G6WICLD7.handleImportUsing,
   hasProperty: () => import_chunk_JDC43A3I.hasProperty,
-  isClassVariable: () => import_chunk_7GXXJDR3.isClassVariable,
-  isLocal: () => import_chunk_7GXXJDR3.isLocal,
-  isLookupCandidate: () => import_chunk_7GXXJDR3.isLookupCandidate,
-  isStateNode: () => import_chunk_7GXXJDR3.isStateNode,
-  lookupByFullName: () => import_chunk_7GXXJDR3.lookupByFullName,
-  lookupNext: () => import_chunk_7GXXJDR3.lookupNext,
-  lookupResultContains: () => import_chunk_7GXXJDR3.lookupResultContains,
-  lookupWithType: () => import_chunk_7GXXJDR3.lookupWithType,
-  makeToyboxLink: () => import_chunk_7GXXJDR3.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_7GXXJDR3.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_7GXXJDR3.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_7GXXJDR3.parseSdkVersion,
-  popRootNode: () => import_chunk_7GXXJDR3.popRootNode,
-  pushRootNode: () => import_chunk_7GXXJDR3.pushRootNode,
-  resolveDiagnostics: () => import_chunk_7GXXJDR3.resolveDiagnostics,
-  resolveDiagnosticsMap: () => import_chunk_7GXXJDR3.resolveDiagnosticsMap,
-  sameLookupResult: () => import_chunk_7GXXJDR3.sameLookupResult,
+  isClassVariable: () => import_chunk_G6WICLD7.isClassVariable,
+  isLocal: () => import_chunk_G6WICLD7.isLocal,
+  isLookupCandidate: () => import_chunk_G6WICLD7.isLookupCandidate,
+  isStateNode: () => import_chunk_G6WICLD7.isStateNode,
+  lookupByFullName: () => import_chunk_G6WICLD7.lookupByFullName,
+  lookupNext: () => import_chunk_G6WICLD7.lookupNext,
+  lookupResultContains: () => import_chunk_G6WICLD7.lookupResultContains,
+  lookupWithType: () => import_chunk_G6WICLD7.lookupWithType,
+  makeToyboxLink: () => import_chunk_G6WICLD7.makeToyboxLink,
+  mapVarDeclsByType: () => import_chunk_G6WICLD7.mapVarDeclsByType,
+  markInvokeClassMethod: () => import_chunk_G6WICLD7.markInvokeClassMethod,
+  parseSdkVersion: () => import_chunk_G6WICLD7.parseSdkVersion,
+  popRootNode: () => import_chunk_G6WICLD7.popRootNode,
+  pushRootNode: () => import_chunk_G6WICLD7.pushRootNode,
+  resolveDiagnostics: () => import_chunk_G6WICLD7.resolveDiagnostics,
+  resolveDiagnosticsMap: () => import_chunk_G6WICLD7.resolveDiagnosticsMap,
+  sameLookupResult: () => import_chunk_G6WICLD7.sameLookupResult,
   traverseAst: () => import_chunk_JDC43A3I.traverseAst,
-  variableDeclarationName: () => import_chunk_7GXXJDR3.variableDeclarationName,
-  visitReferences: () => import_chunk_7GXXJDR3.visitReferences,
-  visit_resources: () => import_chunk_7GXXJDR3.visit_resources,
-  visitorNode: () => import_chunk_7GXXJDR3.visitorNode
+  variableDeclarationName: () => import_chunk_G6WICLD7.variableDeclarationName,
+  visitReferences: () => import_chunk_G6WICLD7.visitReferences,
+  visit_resources: () => import_chunk_G6WICLD7.visit_resources,
+  visitorNode: () => import_chunk_G6WICLD7.visitorNode
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_7GXXJDR3 = require("./chunk-7GXXJDR3.cjs");
+var import_chunk_G6WICLD7 = require("./chunk-G6WICLD7.cjs");
 var import_chunk_NHZRKHZO = require("./chunk-NHZRKHZO.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_7GXXJDR3.init_api)();
+(0, import_chunk_G6WICLD7.init_api)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,
   collectNamespaces,
   createDocumentationMap,
+  declKey,
   diagnostic,
   diagnosticHelper,
   findNamesInScope,

package/build/{chunk-7GXXJDR3.cjs → chunk-G6WICLD7.cjs}

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_7GXXJDR3_exports = {};
-__export(chunk_7GXXJDR3_exports, {
+var chunk_G6WICLD7_exports = {};
+__export(chunk_G6WICLD7_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -44,6 +44,7 @@ __export(chunk_7GXXJDR3_exports, {
   connectiq: () => connectiq,
   couldBe: () => couldBe,
   createDocumentationMap: () => createDocumentationMap,
+  declKey: () => declKey,
   defaultConfig: () => defaultConfig,
   diagnostic: () => diagnostic,
   diagnosticHelper: () => diagnosticHelper,
@@ -138,7 +139,7 @@ __export(chunk_7GXXJDR3_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_7GXXJDR3_exports);
+module.exports = __toCommonJS(chunk_G6WICLD7_exports);
 var import_chunk_NHZRKHZO = require("./chunk-NHZRKHZO.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -9273,89 +9274,84 @@ function printBlockTrailer(block) {
     `Succs: ${(block.succs || []).map((block2) => block2.order).join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`
   );
 }
-function filterDecls(decls, possible, name) {
+function filterDecls(state, decls, next) {
+  const possible = (0, import_chunk_JDC43A3I.hasProperty)(state.allDeclarations, next.name) && state.allDeclarations[next.name];
   if (!possible)
     return [null, null];
-  const result = decls.reduce(
-    (cur, decl) => {
-      let declSups;
-      const found = possible.reduce((flag, poss) => {
-        if (decl === poss || poss.type === "ClassDeclaration" && getSuperClasses(poss)?.has(decl)) {
-          if (!cur[0]) {
-            cur = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
-          }
-          cur[0].add(poss);
-          cur[1].add(poss);
-          return true;
-        } else if (declSups !== void 0 ? declSups?.has(poss) : decl.type === "ClassDeclaration" && (declSups = getSuperClasses(decl))?.has(poss)) {
-          if (!cur[0]) {
-            cur = [/* @__PURE__ */ new Set([decl]), /* @__PURE__ */ new Set([poss])];
-          } else {
-            cur[0].add(decl);
-            if (Array.from(cur[1]).every((d) => {
-              if (decl === d)
-                return false;
-              if (!declSups.has(d))
-                return true;
-              if (d.type === "ClassDeclaration" && getSuperClasses(d)?.has(poss)) {
-                return false;
-              }
-              if (poss.type === "ClassDeclaration" && getSuperClasses(poss)?.has(d)) {
-                cur[1].delete(d);
-              }
-              return true;
-            })) {
-              cur[1].add(poss);
-            }
+  const result = decls.reduce((cur, { sn: decl, exact }) => {
+    let declSups;
+    const getDeclSups = () => declSups !== void 0 ? declSups : decl.type === "ClassDeclaration" ? declSups = getSuperClasses(decl) : null;
+    const found = possible.reduce((flag, poss) => {
+      if (decl === poss || !exact && poss.type === "ClassDeclaration" && getSuperClasses(poss)?.has(decl)) {
+        if (!cur) {
+          cur = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+        }
+        cur[0].add(poss);
+        cur[1].add(poss);
+        if (cur[2].size && decl === poss && decl.type === "ClassDeclaration") {
+          const posSupers = getSuperClasses(decl);
+          if (posSupers) {
+            cur[2].forEach((s) => posSupers.has(s) && cur[2].delete(s));
           }
-          return true;
         }
-        return flag;
-      }, false);
-      if (!found) {
-        let d = [decl];
-        do {
-          d.forEach((d2) => {
-            const stack = d2.stack;
-            possible.forEach((poss) => {
-              for (let i = stack.length; i--; ) {
-                const sn = stack[i].sn;
-                if (sn.decls === poss.decls) {
-                  if (!cur[0]) {
-                    cur = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
-                  }
-                  cur[0].add(decl);
-                  cur[1].add(poss);
-                  break;
-                }
-                if ((0, import_chunk_JDC43A3I.hasProperty)(sn.decls, name)) {
-                  break;
+        return true;
+      } else if (poss.type === "ClassDeclaration" && getDeclSups()?.has(poss)) {
+        if (!cur) {
+          cur = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+        }
+        cur[0].add(decl);
+        const supers = Array.from(cur[2]);
+        if (!supers.some((s) => getSuperClasses(s)?.has(poss))) {
+          const posSupers = getSuperClasses(poss);
+          posSupers && supers.forEach((s) => posSupers.has(s) && cur[2].delete(s));
+          cur[2].add(poss);
+        }
+        return true;
+      }
+      return flag;
+    }, false);
+    if (!found) {
+      let d = [decl];
+      do {
+        d.forEach((d2) => {
+          const stack = d2.stack;
+          possible.forEach((poss) => {
+            for (let i = stack.length; i--; ) {
+              const sn = stack[i].sn;
+              if (sn.decls === poss.decls) {
+                if (!cur) {
+                  cur = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
                 }
+                cur[0].add(decl);
+                cur[1].add(poss);
+                break;
+              }
+              if ((0, import_chunk_JDC43A3I.hasProperty)(sn.decls, next.name)) {
+                break;
               }
-            });
-          });
-          d = d.flatMap((d2) => {
-            if (d2.type !== "ClassDeclaration" || !d2.superClass || d2.superClass === true) {
-              return [];
             }
-            return d2.superClass;
           });
-        } while (d.length);
-      }
-      return cur;
-    },
-    [null, null]
-  );
-  if (!result[0])
+        });
+        d = d.flatMap((d2) => {
+          if (d2.type !== "ClassDeclaration" || !d2.superClass || d2.superClass === true) {
+            return [];
+          }
+          return d2.superClass;
+        });
+      } while (d.length);
+    }
+    return cur;
+  }, null);
+  if (!result)
     return [null, null];
+  result[2].forEach((c) => result[1].add(c));
   return [Array.from(result[0]), Array.from(result[1])];
 }
 function findObjectDeclsByProperty(state, object, next) {
-  const decls = getStateNodeDeclsFromType(state, object);
+  const decls = getStateNodeDeclsWithExactFromType(state, object);
   if (!decls)
     return [null, null];
-  const possibleDecls = (0, import_chunk_JDC43A3I.hasProperty)(state.allDeclarations, next.name) && state.allDeclarations[next.name];
-  return filterDecls(decls, possibleDecls, next.name);
+  return filterDecls(state, decls, next);
 }
 function refineObjectTypeByDecls(istate, object, trueDecls) {
   const refinedType = typeFromTypeStateNodes(istate.state, trueDecls);
@@ -12207,6 +12203,9 @@ function setUnionComponent(v, tag, c) {
   }
 }
 function getStateNodeDeclsFromType(state, object) {
+  return getStateNodeDeclsWithExactFromType(state, object).map(({ sn }) => sn);
+}
+function getStateNodeDeclsWithExactFromType(state, object) {
   const decls = [];
   if (object.value != null && object.type & (4096 | 16384 | 32768)) {
     forEachUnionComponent(
@@ -12218,20 +12217,15 @@ function getStateNodeDeclsFromType(state, object) {
         switch (type.type) {
           case 32768:
             if (type.value.klass.type === 16384 && type.value.klass.value) {
-              if (Array.isArray(type.value.klass.value)) {
-                decls.push(...type.value.klass.value);
-              } else {
-                decls.push(type.value.klass.value);
-              }
+              (0, import_chunk_NHZRKHZO.forEach)(
+                type.value.klass.value,
+                (sn) => decls.push({ sn, exact: false })
+              );
             }
             break;
           case 4096:
           case 16384:
-            if (Array.isArray(type.value)) {
-              decls.push(...type.value);
-            } else {
-              decls.push(type.value);
-            }
+            (0, import_chunk_NHZRKHZO.forEach)(type.value, (sn) => decls.push({ sn, exact: true }));
             break;
         }
       }
@@ -12251,7 +12245,7 @@ function getStateNodeDeclsFromType(state, object) {
       }
       const name = `Toybox.Lang.${typeTagName(bit)}`;
       const sns = lookupByFullName(state, name);
-      sns.forEach((sn) => isStateNode(sn) && decls.push(sn));
+      sns.forEach((sn) => isStateNode(sn) && decls.push({ sn, exact: true }));
       bits = next;
     } while (bits);
   }
@@ -12804,7 +12798,7 @@ function buildTypeInfo(state, root, optimizeEquivalencies) {
       }
     }
     const stack = root.stack.slice();
-    pushRootNode(stack, root);
+    pushRootNode(state, stack, root);
     const { istate, redo } = propagateTypes(
       { ...state, stack },
       root,
@@ -13834,7 +13828,7 @@ function propagateTypes(state, root, graph, optimizeEquivalencies, copyPropStore
           let result = null;
           if (truthy === (event.kind === 6)) {
             result = intersection(left, right);
-          } else if (isExact(right)) {
+          } else if (isExact(right) || right.type === 6) {
             if (right.type === 32768) {
               if (right.value == null) {
                 result = cloneType(left);
@@ -16846,6 +16840,10 @@ function collectClassInfo(state) {
   state.allClasses.forEach((elm) => {
     if (elm.stack[elm.stack.length - 1].sn.type === "ClassDeclaration") {
       elm.stack = elm.stack.slice(0, 1);
+      if (!(0, import_chunk_JDC43A3I.hasProperty)(state.nestedClasses, elm.name)) {
+        state.nestedClasses[elm.name] = [];
+      }
+      state.nestedClasses[elm.name].push(elm);
     }
     if (elm.node.superClass) {
       const [name, lookupDefns] = state.lookup(
@@ -16980,6 +16978,7 @@ async function analyze(fnMap, resourcesMap, manifestXML, config, allowParseError
     config,
     allFunctions: {},
     allClasses: [],
+    nestedClasses: {},
     allModules: /* @__PURE__ */ new Set(),
     shouldExclude(node) {
       if ("attrs" in node && node.attrs && "attributes" in node.attrs && node.attrs.attributes && node.loc?.source) {
@@ -18899,12 +18898,12 @@ function checkCompilerVersion(version, sdkVer) {
   }
   return sdkVer <= v2;
 }
-function pushRootNode(stack, root) {
+function pushRootNode(state, stack, root) {
   if (root.type === "Program")
     return;
   const sn = root.stack?.at(-1)?.sn?.decls?.[root.name]?.find(
     (sn2) => sn2.type === root.type && (root.nodes != null || sn2.node === root.node)
-  );
+  ) ?? state.nestedClasses[root.name]?.find((d) => d.node === root.node);
   if (!sn) {
     throw new Error(`Invalid stack for node ${root.fullName}`);
   }
@@ -19504,6 +19503,15 @@ function stateFuncs() {
               case "ModuleDeclaration": {
                 const parent = this.top().sn;
                 const name = "id" in node ? node.id && node.id.name : void 0;
+                if (name && node.type === "ClassDeclaration") {
+                  const sn = this.nestedClasses?.[name]?.find(
+                    (d) => d.node === node
+                  );
+                  if (sn) {
+                    this.stack.push({ sn });
+                    break;
+                  }
+                }
                 const fullName = this.stack.map((e) => e.sn.name).concat(name).filter((e) => e != null).join(".");
                 const elm = {
                   type: node.type,
@@ -28599,7 +28607,13 @@ function evaluate_locals(assignments) {
   while (true) {
     assignments = assignments.filter((a) => {
       if (a.names.length === 1 && a.values.every((v) => v.type === "Literal")) {
-        locals[a.names[0]] = a.values;
+        locals[a.names[0]] = a.values.map((v) => {
+          if ("source" in v) {
+            v = { ...v };
+            delete v.source;
+          }
+          return v;
+        });
         return false;
       }
       return true;
@@ -29551,13 +29565,13 @@ async function analyze_module_types(state) {
         const saved = istate.state.stack;
         root.nodes.forEach((stack, node) => {
           istate.state.stack = stack.slice();
-          pushRootNode(istate.state.stack, root);
+          pushRootNode(istate.state, istate.state.stack, root);
           evaluate(istate, node);
           popRootNode(istate.state.stack, root);
         });
         istate.state.stack = saved;
       } else {
-        pushRootNode(istate.state.stack, root);
+        pushRootNode(istate.state, istate.state.stack, root);
         evaluate(istate, root.node);
         popRootNode(istate.state.stack, root);
       }
@@ -30184,7 +30198,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_NHZRKHZO.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1726412336564 < opt_time) {
+      if (source_time < opt_time && 1727624657655 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -30222,7 +30236,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.75",
+            optimizerVersion: "1.1.77",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -31057,6 +31071,7 @@ var init_sdk_util = (0, import_chunk_ABYVSU2C.__esm)({
   connectiq,
   couldBe,
   createDocumentationMap,
+  declKey,
   defaultConfig,
   diagnostic,
   diagnosticHelper,

package/build/optimizer.cjs

@@ -18,30 +18,30 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var optimizer_exports = {};
 __export(optimizer_exports, {
-  StateNodeAttributes: () => import_chunk_7GXXJDR3.StateNodeAttributes,
-  buildConfigDescription: () => import_chunk_7GXXJDR3.buildConfigDescription,
-  buildOptimizedProject: () => import_chunk_7GXXJDR3.buildOptimizedProject,
+  StateNodeAttributes: () => import_chunk_G6WICLD7.StateNodeAttributes,
+  buildConfigDescription: () => import_chunk_G6WICLD7.buildConfigDescription,
+  buildOptimizedProject: () => import_chunk_G6WICLD7.buildOptimizedProject,
   copyRecursiveAsNeeded: () => import_chunk_NHZRKHZO.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_7GXXJDR3.defaultConfig,
-  display: () => import_chunk_7GXXJDR3.display,
-  generateOneConfig: () => import_chunk_7GXXJDR3.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_7GXXJDR3.generateOptimizedProject,
-  getConfig: () => import_chunk_7GXXJDR3.getConfig,
-  getFnMapAnalysis: () => import_chunk_7GXXJDR3.getFnMapAnalysis,
-  getProjectAnalysis: () => import_chunk_7GXXJDR3.getProjectAnalysis,
-  get_jungle: () => import_chunk_7GXXJDR3.get_jungle,
-  isErrorWithLocation: () => import_chunk_7GXXJDR3.isErrorWithLocation,
-  launchSimulator: () => import_chunk_7GXXJDR3.launchSimulator,
-  manifestProducts: () => import_chunk_7GXXJDR3.manifestProducts,
-  mctree: () => import_chunk_7GXXJDR3.mctree,
-  simulateProgram: () => import_chunk_7GXXJDR3.simulateProgram
+  defaultConfig: () => import_chunk_G6WICLD7.defaultConfig,
+  display: () => import_chunk_G6WICLD7.display,
+  generateOneConfig: () => import_chunk_G6WICLD7.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_G6WICLD7.generateOptimizedProject,
+  getConfig: () => import_chunk_G6WICLD7.getConfig,
+  getFnMapAnalysis: () => import_chunk_G6WICLD7.getFnMapAnalysis,
+  getProjectAnalysis: () => import_chunk_G6WICLD7.getProjectAnalysis,
+  get_jungle: () => import_chunk_G6WICLD7.get_jungle,
+  isErrorWithLocation: () => import_chunk_G6WICLD7.isErrorWithLocation,
+  launchSimulator: () => import_chunk_G6WICLD7.launchSimulator,
+  manifestProducts: () => import_chunk_G6WICLD7.manifestProducts,
+  mctree: () => import_chunk_G6WICLD7.mctree,
+  simulateProgram: () => import_chunk_G6WICLD7.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_7GXXJDR3 = require("./chunk-7GXXJDR3.cjs");
+var import_chunk_G6WICLD7 = require("./chunk-G6WICLD7.cjs");
 var import_chunk_NHZRKHZO = require("./chunk-NHZRKHZO.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_7GXXJDR3.init_optimizer)();
+(0, import_chunk_G6WICLD7.init_optimizer)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StateNodeAttributes,

package/build/sdk-util.cjs

@@ -18,25 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sdk_util_exports = {};
 __export(sdk_util_exports, {
-  SectionKinds: () => import_chunk_7GXXJDR3.SectionKinds,
-  appSupport: () => import_chunk_7GXXJDR3.appSupport,
-  connectiq: () => import_chunk_7GXXJDR3.connectiq,
-  getDeviceInfo: () => import_chunk_7GXXJDR3.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_7GXXJDR3.getFunctionDocumentation,
-  getLanguages: () => import_chunk_7GXXJDR3.getLanguages,
-  getSdkPath: () => import_chunk_7GXXJDR3.getSdkPath,
-  isWin: () => import_chunk_7GXXJDR3.isWin,
-  optimizeProgram: () => import_chunk_7GXXJDR3.optimizeProgram,
-  readPrg: () => import_chunk_7GXXJDR3.readPrg,
-  readPrgWithOffsets: () => import_chunk_7GXXJDR3.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_7GXXJDR3.xml_util_exports
+  SectionKinds: () => import_chunk_G6WICLD7.SectionKinds,
+  appSupport: () => import_chunk_G6WICLD7.appSupport,
+  connectiq: () => import_chunk_G6WICLD7.connectiq,
+  getDeviceInfo: () => import_chunk_G6WICLD7.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_G6WICLD7.getFunctionDocumentation,
+  getLanguages: () => import_chunk_G6WICLD7.getLanguages,
+  getSdkPath: () => import_chunk_G6WICLD7.getSdkPath,
+  isWin: () => import_chunk_G6WICLD7.isWin,
+  optimizeProgram: () => import_chunk_G6WICLD7.optimizeProgram,
+  readPrg: () => import_chunk_G6WICLD7.readPrg,
+  readPrgWithOffsets: () => import_chunk_G6WICLD7.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_G6WICLD7.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_7GXXJDR3 = require("./chunk-7GXXJDR3.cjs");
+var import_chunk_G6WICLD7 = require("./chunk-G6WICLD7.cjs");
 var import_chunk_NHZRKHZO = require("./chunk-NHZRKHZO.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_7GXXJDR3.init_sdk_util)();
+(0, import_chunk_G6WICLD7.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/api.d.ts

@@ -10,7 +10,7 @@ export { visitReferences, visitorNode } from "./visitor";
 export { hasProperty, traverseAst, visit_resources };
 export declare function parseSdkVersion(version: string | undefined): number;
 export declare function checkCompilerVersion(version: string, sdkVer: number): boolean | undefined;
-export declare function pushRootNode(stack: ProgramStateStack, root: RootStateNode): void;
+export declare function pushRootNode(state: ProgramStateAnalysis, stack: ProgramStateStack, root: RootStateNode): void;
 export declare function popRootNode(stack: ProgramStateStack, root: RootStateNode): void;
 export declare function getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): Promise<ProgramStateNode>;
 export declare function isStateNode(node: {
@@ -19,6 +19,7 @@ export declare function isStateNode(node: {
 export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
 type DeclKind = "decls" | "type_decls";
 export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function declKey(decl: StateNodeDecl): string | mctree.Identifier | mctree.Program | mctree.VariableDeclarator | mctree.EnumStringMember | mctree.BlockStatement | mctree.ForStatement | mctree.ClassDeclaration | mctree.EnumDeclaration | mctree.FunctionDeclaration | mctree.TypedefDeclaration | mctree.AsIdentifier | undefined;
 export declare function lookupResultContains(a: LookupDefinition[], b: LookupDefinition[]): boolean;
 export declare function isLookupCandidate(node: mctree.MemberExpression): false | mctree.Identifier;
 export declare function lookupNext(state: ProgramStateLive, results: LookupDefinition[], decls: DeclKind, property: mctree.Identifier): LookupDefinition[] | null;

package/build/src/optimizer-types.d.ts

@@ -136,6 +136,7 @@ export type ByNameStateNodeDecls = ModuleStateNode | ClassStateNode | FunctionSt
 export type ProgramState = {
     allFunctions?: Record<string, FunctionStateNode[]>;
     allClasses?: ClassStateNode[];
+    nestedClasses?: Record<string, ClassStateNode[]>;
     allModules?: Set<ModuleStateNode>;
     invokeInfo?: FunctionInfo;
     allDeclarations?: Record<string, ByNameStateNodeDecls[]>;
@@ -190,7 +191,7 @@ export type Finalized<T, Keys extends keyof T> = T & {
     [key in Keys]-?: NonNullable<T[key]>;
 };
 export type ProgramStateLive = Finalized<ProgramState, "stack" | "top" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
-export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allModules" | "allFunctions" | "fnMap" | "allDeclarations" | "invokeInfo">;
+export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "nestedClasses" | "allModules" | "allFunctions" | "fnMap" | "allDeclarations" | "invokeInfo">;
 export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
 export type ExcludeAnnotationsMap = {
     [key: string]: boolean;

package/build/src/type-flow/types.d.ts

@@ -211,4 +211,8 @@ export declare function forEachUnionComponent(v: ExactOrUnion, bits: TypeTag, fn
 export declare function getUnionComponent<T extends ExactTypeTags>(v: ExactOrUnion, tag: T): ExactData<T> | null;
 export declare function setUnionComponent<T extends ExactTypeTags>(v: ExactOrUnion, tag: T, c: ExactData<T>): void;
 export declare function getStateNodeDeclsFromType(state: ProgramStateAnalysis, object: ExactOrUnion): StateNode[];
+export declare function getStateNodeDeclsWithExactFromType(state: ProgramStateAnalysis, object: ExactOrUnion): {
+    sn: StateNode;
+    exact: boolean;
+}[];
 export {};

package/build/worker-thread.cjs

@@ -21,17 +21,17 @@ __export(worker_thread_exports, {
   default: () => worker_thread_default
 });
 module.exports = __toCommonJS(worker_thread_exports);
-var import_chunk_7GXXJDR3 = require("./chunk-7GXXJDR3.cjs");
+var import_chunk_G6WICLD7 = require("./chunk-G6WICLD7.cjs");
 var import_chunk_NHZRKHZO = require("./chunk-NHZRKHZO.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
 var import_node_worker_threads = require("node:worker_threads");
 var require_worker_thread = (0, import_chunk_ABYVSU2C.__commonJS)({
   "src/worker-thread.ts"() {
-    (0, import_chunk_7GXXJDR3.init_worker_task)();
+    (0, import_chunk_G6WICLD7.init_worker_task)();
     if (import_node_worker_threads.parentPort) {
       import_node_worker_threads.parentPort.on("message", async (task) => {
-        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_7GXXJDR3.performTask)(task));
+        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_G6WICLD7.performTask)(task));
       });
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "commonjs",
-  "version": "1.1.75",
+  "version": "1.1.77",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",