@markw65/monkeyc-optimizer 1.1.96 → 1.1.97

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the "monkeyc-optimizer" package will be documented in this file.
 
+### 1.1.97
+
+- Fix [$ has :UNDEFINED error (#79)](https://github.com/markw65/monkeyc-optimizer/issues/79#top)
+- Fix ["Generate Optimized Project" issue due to inlining code into another class (#76)](https://github.com/markw65/monkeyc-optimizer/issues/76#top)
+- Fix ["Generate Optimized Project" produces code with syntax error (#77)](https://github.com/markw65/monkeyc-optimizer/issues/77#top)
+
 ### 1.1.96
 
 - Update to [@markw65/prettier-plugin-monkeyc@1.0.66](https://github.com/markw65/prettier-plugin-monkeyc/blob/main/CHANGELOG.md#1066)

package/build/api.cjs

@@ -18,52 +18,52 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  checkCompilerVersion: () => import_chunk_4C4RQPFP.checkCompilerVersion,
-  clearDiagnostics: () => import_chunk_4C4RQPFP.clearDiagnostics,
-  collectNamespaces: () => import_chunk_4C4RQPFP.collectNamespaces,
-  createDocumentationMap: () => import_chunk_4C4RQPFP.createDocumentationMap,
-  declKey: () => import_chunk_4C4RQPFP.declKey,
-  diagnostic: () => import_chunk_4C4RQPFP.diagnostic,
-  diagnosticHelper: () => import_chunk_4C4RQPFP.diagnosticHelper,
-  findNamesInScope: () => import_chunk_4C4RQPFP.findNamesInScope,
-  findUsingForNode: () => import_chunk_4C4RQPFP.findUsingForNode,
-  formatAst: () => import_chunk_4C4RQPFP.formatAst,
-  formatAstLongLines: () => import_chunk_4C4RQPFP.formatAstLongLines,
-  formatScopedName: () => import_chunk_4C4RQPFP.formatScopedName,
-  getApiFunctionInfo: () => import_chunk_4C4RQPFP.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_4C4RQPFP.getApiMapping,
-  getSuperClasses: () => import_chunk_4C4RQPFP.getSuperClasses,
-  handleImportUsing: () => import_chunk_4C4RQPFP.handleImportUsing,
+  checkCompilerVersion: () => import_chunk_WP3SDGBT.checkCompilerVersion,
+  clearDiagnostics: () => import_chunk_WP3SDGBT.clearDiagnostics,
+  collectNamespaces: () => import_chunk_WP3SDGBT.collectNamespaces,
+  createDocumentationMap: () => import_chunk_WP3SDGBT.createDocumentationMap,
+  declKey: () => import_chunk_WP3SDGBT.declKey,
+  diagnostic: () => import_chunk_WP3SDGBT.diagnostic,
+  diagnosticHelper: () => import_chunk_WP3SDGBT.diagnosticHelper,
+  findNamesInScope: () => import_chunk_WP3SDGBT.findNamesInScope,
+  findUsingForNode: () => import_chunk_WP3SDGBT.findUsingForNode,
+  formatAst: () => import_chunk_WP3SDGBT.formatAst,
+  formatAstLongLines: () => import_chunk_WP3SDGBT.formatAstLongLines,
+  formatScopedName: () => import_chunk_WP3SDGBT.formatScopedName,
+  getApiFunctionInfo: () => import_chunk_WP3SDGBT.getApiFunctionInfo,
+  getApiMapping: () => import_chunk_WP3SDGBT.getApiMapping,
+  getSuperClasses: () => import_chunk_WP3SDGBT.getSuperClasses,
+  handleImportUsing: () => import_chunk_WP3SDGBT.handleImportUsing,
   hasProperty: () => import_chunk_UBAYZSM3.hasProperty,
-  isClassVariable: () => import_chunk_4C4RQPFP.isClassVariable,
-  isLocal: () => import_chunk_4C4RQPFP.isLocal,
-  isLookupCandidate: () => import_chunk_4C4RQPFP.isLookupCandidate,
-  isStateNode: () => import_chunk_4C4RQPFP.isStateNode,
-  lookupByFullName: () => import_chunk_4C4RQPFP.lookupByFullName,
-  lookupNext: () => import_chunk_4C4RQPFP.lookupNext,
-  lookupResultContains: () => import_chunk_4C4RQPFP.lookupResultContains,
-  lookupWithType: () => import_chunk_4C4RQPFP.lookupWithType,
-  makeToyboxLink: () => import_chunk_4C4RQPFP.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_4C4RQPFP.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_4C4RQPFP.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_4C4RQPFP.parseSdkVersion,
-  popRootNode: () => import_chunk_4C4RQPFP.popRootNode,
-  pushRootNode: () => import_chunk_4C4RQPFP.pushRootNode,
-  resolveDiagnostics: () => import_chunk_4C4RQPFP.resolveDiagnostics,
-  resolveDiagnosticsMap: () => import_chunk_4C4RQPFP.resolveDiagnosticsMap,
-  sameLookupResult: () => import_chunk_4C4RQPFP.sameLookupResult,
+  isClassVariable: () => import_chunk_WP3SDGBT.isClassVariable,
+  isLocal: () => import_chunk_WP3SDGBT.isLocal,
+  isLookupCandidate: () => import_chunk_WP3SDGBT.isLookupCandidate,
+  isStateNode: () => import_chunk_WP3SDGBT.isStateNode,
+  lookupByFullName: () => import_chunk_WP3SDGBT.lookupByFullName,
+  lookupNext: () => import_chunk_WP3SDGBT.lookupNext,
+  lookupResultContains: () => import_chunk_WP3SDGBT.lookupResultContains,
+  lookupWithType: () => import_chunk_WP3SDGBT.lookupWithType,
+  makeToyboxLink: () => import_chunk_WP3SDGBT.makeToyboxLink,
+  mapVarDeclsByType: () => import_chunk_WP3SDGBT.mapVarDeclsByType,
+  markInvokeClassMethod: () => import_chunk_WP3SDGBT.markInvokeClassMethod,
+  parseSdkVersion: () => import_chunk_WP3SDGBT.parseSdkVersion,
+  popRootNode: () => import_chunk_WP3SDGBT.popRootNode,
+  pushRootNode: () => import_chunk_WP3SDGBT.pushRootNode,
+  resolveDiagnostics: () => import_chunk_WP3SDGBT.resolveDiagnostics,
+  resolveDiagnosticsMap: () => import_chunk_WP3SDGBT.resolveDiagnosticsMap,
+  sameLookupResult: () => import_chunk_WP3SDGBT.sameLookupResult,
   traverseAst: () => import_chunk_UBAYZSM3.traverseAst,
-  variableDeclarationName: () => import_chunk_4C4RQPFP.variableDeclarationName,
-  visitReferences: () => import_chunk_4C4RQPFP.visitReferences,
-  visit_resources: () => import_chunk_4C4RQPFP.visit_resources,
-  visitorNode: () => import_chunk_4C4RQPFP.visitorNode
+  variableDeclarationName: () => import_chunk_WP3SDGBT.variableDeclarationName,
+  visitReferences: () => import_chunk_WP3SDGBT.visitReferences,
+  visit_resources: () => import_chunk_WP3SDGBT.visit_resources,
+  visitorNode: () => import_chunk_WP3SDGBT.visitorNode
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_4C4RQPFP = require("./chunk-4C4RQPFP.cjs");
+var import_chunk_WP3SDGBT = require("./chunk-WP3SDGBT.cjs");
 var import_chunk_IJS7AYMN = require("./chunk-IJS7AYMN.cjs");
 var import_chunk_UBAYZSM3 = require("./chunk-UBAYZSM3.cjs");
 var import_chunk_VS2QQHAK = require("./chunk-VS2QQHAK.cjs");
-(0, import_chunk_4C4RQPFP.init_api)();
+(0, import_chunk_WP3SDGBT.init_api)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,

package/build/{chunk-4C4RQPFP.cjs → chunk-WP3SDGBT.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_4C4RQPFP_exports = {};
-__export(chunk_4C4RQPFP_exports, {
+var chunk_WP3SDGBT_exports = {};
+__export(chunk_WP3SDGBT_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -140,7 +140,7 @@ __export(chunk_4C4RQPFP_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_4C4RQPFP_exports);
+module.exports = __toCommonJS(chunk_WP3SDGBT_exports);
 var import_chunk_IJS7AYMN = require("./chunk-IJS7AYMN.cjs");
 var import_chunk_UBAYZSM3 = require("./chunk-UBAYZSM3.cjs");
 var import_chunk_VS2QQHAK = require("./chunk-VS2QQHAK.cjs");
@@ -4351,11 +4351,97 @@ function processInlineBody(state, func, call, root, params) {
       }
       const replacement = fixNodeScope(state, node, lookupStack);
       if (!replacement) {
-        failed = true;
+        if (!failed) {
+          inlineDiagnostic(state, func, call, null);
+          failed = true;
+        }
         inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
       }
       return replacement;
     };
+    const fixupScopedType = (node) => {
+      if (node.type === "Identifier") {
+        const save = state.inType;
+        state.inType = 1;
+        const replacement = fixNodeScope(state, node, lookupStack);
+        state.inType = save;
+        if (!replacement) {
+          if (!failed) {
+            inlineDiagnostic(state, func, call, null);
+            failed = true;
+          }
+          inlineDiagnostic(
+            state,
+            func,
+            call,
+            `Failed to resolve '${node.name}'`
+          );
+        }
+        return replacement;
+      }
+      const object = fixupScopedType(node.object);
+      return {
+        ...node,
+        object
+      };
+    };
+    const fixupType = (node) => {
+      if (typeof node === "string") {
+        return node;
+      }
+      const { type } = node;
+      switch (type) {
+        case "TypeSpecList":
+          return {
+            ...node,
+            ts: node.ts.map((spec) => fixupType(spec))
+          };
+        case "ArrayExpression":
+          return {
+            ...node,
+            elements: node.elements.map(
+              (e) => fixupType(e)
+            )
+          };
+        case "ObjectExpression":
+          return {
+            ...node,
+            properties: node.properties.map((property) => {
+              const prop = property;
+              return { ...prop, right: fixupType(prop.right) };
+            })
+          };
+        case "TypeSpecPart": {
+          const name = typeof node.name === "string" ? node.name : fixupScopedType(node.name);
+          if (node.body) {
+            return { ...node, name };
+          }
+          if (node.callspec) {
+            return {
+              ...node,
+              callspec: {
+                ...node.callspec,
+                params: node.callspec.params.map(
+                  (p) => p.type === "BinaryExpression" ? { ...p, right: fixupType(p.right) } : p
+                ),
+                returnType: {
+                  ...node.callspec.returnType,
+                  argument: fixupType(node.callspec.returnType.argument)
+                }
+              }
+            };
+          }
+          return node.generics ? {
+            ...node,
+            name,
+            generics: node.generics.map((ts) => fixupType(ts))
+          } : { ...node, name };
+          break;
+        }
+        default:
+          unhandledType(type);
+      }
+    };
     state.post = function(node) {
       if (failed) return post.call(this, node);
       let replacement = null;
@@ -4379,6 +4465,11 @@ function processInlineBody(state, func, call, root, params) {
         case "Identifier":
           replacement = fixId(node);
           break;
+        case "BinaryExpression":
+          if (node.operator === "as") {
+            node.right = fixupType(node.right);
+          }
+          break;
       }
       const ret2 = post.call(this, replacement || node);
       return ret2 === false || ret2 ? ret2 : replacement;
@@ -4749,7 +4840,7 @@ function applyTypeIfNeeded(node) {
   return node;
 }
 function fixNodeScope(state, lookupNode, nodeStack) {
-  if (lookupNode.type === "Identifier") {
+  if (lookupNode.type === "Identifier" && !state.inType) {
     const locals = state.localsStack[state.localsStack.length - 1];
     const { map: map2 } = locals;
     if (!map2) throw new Error("No local variable map!");
@@ -4861,6 +4952,7 @@ var init_inliner = (0, import_chunk_VS2QQHAK.__esm)({
     init_function_info();
     init_optimizer_types();
     init_variable_renamer();
+    init_data_flow();
   }
 });
 function pragmaChecker(state, ast, diagnostics) {
@@ -12934,9 +13026,10 @@ function propagateTypes(state, root, graph, optimizeEquivalencies, copyPropStore
     }
     if (copyPropStores) {
       copyPropStores.forEach(({ ref, ant }, node) => {
+        const result = nodeCopyProp.get(node) !== ref ? "Failed" : "Success";
         (0, import_chunk_IJS7AYMN.log)(
           formatAstLongLines(node).then(
-            (nodeStr) => `copy-prop-store: ${nodeStr}${ant ? "!" : ""} => ${nodeCopyProp.get(node) !== ref ? "Failed" : "Success"}`
+            (nodeStr) => `copy-prop-store: ${nodeStr}${ant ? "!" : ""} => ${result}`
           )
         );
       });
@@ -14271,7 +14364,7 @@ var init_pre = (0, import_chunk_VS2QQHAK.__esm)({
     LocalRefCost = 2;
   }
 });
-function minimizeModules(ast, state) {
+async function minimizeModules(ast, state) {
   const { pre, post } = state;
   try {
     const replacementMap = /* @__PURE__ */ new Map();
@@ -14350,7 +14443,7 @@ function minimizeModules(ast, state) {
       return null;
     };
     delete state.post;
-    collectNamespaces(ast, state);
+    await collectNamespaces(ast, state);
     const mappedNames = /* @__PURE__ */ new Map();
     replacementMap.forEach((value2, key) => {
       let name;
@@ -14623,11 +14716,15 @@ function beforeEvaluate(istate, node) {
     case "BinaryExpression":
       if (node.operator === "has" && node.right.type === "UnaryExpression" && node.right.operator === ":") {
         const [left, right] = istate.stack.slice(-2);
-        if (left.embeddedEffects || right.embeddedEffects || !hasValue(left.value) || !hasValue(right.value) || !(left.value.type & (4096 | 16384))) {
+        if (left.embeddedEffects || right.embeddedEffects || !hasValue(right.value) || !(left.value.type & (4096 | 16384))) {
+          break;
+        }
+        const leftValues = hasValue(left.value) ? left.value.value : left.value.type === 4096 && node.left.type === "Identifier" && node.left.name === "$" ? istate.state.stack[0].sn : null;
+        if (!leftValues) {
           break;
         }
         const id = node.right.argument;
-        if ((0, import_chunk_IJS7AYMN.every)(left.value.value, (m) => {
+        if ((0, import_chunk_IJS7AYMN.every)(leftValues, (m) => {
           if ((0, import_chunk_UBAYZSM3.hasProperty)(m.decls, id.name)) return false;
           return istate.state.lookup({
             type: "MemberExpression",
@@ -14779,6 +14876,9 @@ function afterEvaluate(istate, node) {
     if (!top.embeddedEffects && hasValue(top.value)) {
       const rep = mcExprFromType(top.value);
       if (rep) {
+        if (rep.type !== "BinaryExpression" || node.type !== "BinaryExpression" || node.operator !== "as" || node.left.type !== "Literal") {
+          istate.rerun = true;
+        }
         top.node = rep;
         return (0, import_chunk_UBAYZSM3.withLoc)(rep, node, node);
       }
@@ -15453,16 +15553,16 @@ async function analyze(fnMap, resourcesMap, manifestXML, config, allowParseError
   markApi = false;
   const state = preState;
   await getFileASTs(fnMap);
-  Object.values(fnMap).forEach((value2) => {
+  for (const value2 of Object.values(fnMap)) {
     const { ast, parserError } = value2;
     if (!ast) {
-      if (allowParseErrors) return;
+      if (allowParseErrors) continue;
       throw parserError || new Error(`Failed to parse ${value2.name}`);
     }
     hasTests = false;
-    collectNamespaces(ast, state);
+    await collectNamespaces(ast, state);
     value2.hasTests = hasTests;
-  });
+  }
   delete state.shouldExclude;
   delete state.pre;
   collectDeclarationsByName(state);
@@ -15471,60 +15571,60 @@ async function analyze(fnMap, resourcesMap, manifestXML, config, allowParseError
   state.nextExposed = {};
   return state;
 }
-function reportMissingSymbols(state, config) {
+async 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?.checkTypes?.toLowerCase() !== "off";
-    const report = (ast) => {
-      visitReferences(state, ast, null, false, (node, results, error) => {
-        if (node.type === "BinaryExpression" && node.operator === "has") {
-          return void 0;
-        }
-        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 & (4 | 2);
-              }
-              return false;
-            });
-          })) {
-            diagnostic(
-              state,
-              node,
-              formatAstLongLines(node).then(
-                (nodeStr) => `The expression ${nodeStr} will fail at runtime using sdk-4.1.6`
-              ),
-              compiler2DiagnosticType
-            );
+    const report = (ast) => visitReferences(state, ast, null, false, (node, results, error) => {
+      if (node.type === "BinaryExpression" && node.operator === "has") {
+        return void 0;
+      }
+      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 void 0;
+          return result.results.some((sn) => {
+            switch (sn.type) {
+              case "VariableDeclarator":
+              case "FunctionDeclaration":
+                return sn.attributes & (4 | 2);
+            }
+            return false;
+          });
+        })) {
+          diagnostic(
+            state,
+            node,
+            formatAstLongLines(node).then(
+              (nodeStr) => `The expression ${nodeStr} will fail at runtime using sdk-4.1.6`
+            ),
+            compiler2DiagnosticType
+          );
         }
-        if (state.inType) {
-          if (!checkTypes || node.type === "Identifier" && node.name.match(/^Void|Null$/)) {
-            return void 0;
-          }
+        return void 0;
+      }
+      if (state.inType) {
+        if (!checkTypes || node.type === "Identifier" && node.name.match(/^Void|Null$/)) {
+          return void 0;
         }
-        diagnostic(
-          state,
-          node,
-          formatAstLongLines(node).then(
-            (nodeStr) => `Undefined symbol ${nodeStr}`
-          ),
-          diagnosticType
-        );
-        return false;
-      });
-    };
-    Object.values(state.fnMap).forEach((v) => v.ast && report(v.ast));
-    state.rezAst && report(state.rezAst);
+      }
+      diagnostic(
+        state,
+        node,
+        formatAstLongLines(node).then(
+          (nodeStr) => `Undefined symbol ${nodeStr}`
+        ),
+        diagnosticType
+      );
+      return false;
+    });
+    for (const v of Object.values(state.fnMap)) {
+      v.ast && await report(v.ast);
+    }
+    state.rezAst && await report(state.rezAst);
   }
 }
 function optimizeNode(istate, node) {
@@ -15919,6 +16019,10 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
         this.currentFunction.info = this.currentFunction.next_info || false;
         delete this.currentFunction.next_info;
         delete this.currentFunction;
+        if (istate.rerun) {
+          again = true;
+          delete istate.rerun;
+        }
         if (istate.stack.length) {
           throw new Error("Stack was not empty");
         }
@@ -16086,50 +16190,47 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
     }
     return null;
   };
-  Object.values(fnMap).forEach((f) => {
-    collectNamespaces(f.ast, state);
-  });
+  for (const f of Object.values(fnMap)) {
+    await collectNamespaces(f.ast, state);
+  }
   let Changes;
   ((Changes2) => {
     Changes2[Changes2["None"] = 0] = "None";
     Changes2[Changes2["Some"] = 1] = "Some";
     Changes2[Changes2["Force"] = 2] = "Force";
   })(Changes || (Changes = {}));
-  const cleanupAll = (state2) => {
+  const cleanupAll = async (state2) => {
     const usedDecls = findRezRefs(state2);
     const pre = state2.pre;
     const post = state2.post;
     try {
       delete state2.pre;
-      return Object.values(fnMap).reduce(
-        (changes, f) => {
-          state2.post = function(node) {
-            if (usedDecls.has(node)) {
-              return null;
-            }
-            const ret = cleanup(this, node, f.ast, usedDecls);
-            if (ret === false) {
+      let changes = 0;
+      for (const f of Object.values(fnMap)) {
+        state2.post = function(node) {
+          if (usedDecls.has(node)) {
+            return null;
+          }
+          const ret = cleanup(this, node, f.ast, usedDecls);
+          if (ret === false) {
+            changes |= 1;
+            this.removeNodeComments(node, f.ast);
+            clearDiagnostics(this, node);
+          } else if (ret) {
+            if (node.type === "EnumDeclaration" && ret.type === "TypedefDeclaration") {
+              changes |= 2;
+            } else {
               changes |= 1;
-              this.removeNodeComments(node, f.ast);
-              clearDiagnostics(this, node);
-            } else if (ret) {
-              if (node.type === "EnumDeclaration" && ret.type === "TypedefDeclaration") {
-                changes |= 2;
-              } else {
-                changes |= 1;
-              }
             }
-            return ret;
-          };
-          collectNamespaces(f.ast, state2);
-          if (changes & 2) {
-            state2.allCached?.forEach((t) => delete t.resolvedType);
           }
-          return changes;
-        },
-        0
-        /* None */
-      );
+          return ret;
+        };
+        await collectNamespaces(f.ast, state2);
+        if (changes & 2) {
+          state2.allCached?.forEach((t) => delete t.resolvedType);
+        }
+      }
+      return changes;
     } finally {
       state2.pre = pre;
       state2.post = post;
@@ -16140,12 +16241,12 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
     state.calledFunctions = {};
     state.exposed = state.nextExposed;
     state.nextExposed = {};
-    Object.values(fnMap).forEach((f) => {
-      collectNamespaces(f.ast, state);
-    });
+    for (const f of Object.values(fnMap)) {
+      await collectNamespaces(f.ast, state);
+    }
     state.exposed = state.nextExposed;
     state.nextExposed = {};
-    const changes = cleanupAll(state);
+    const changes = await cleanupAll(state);
     if (changes & 2 || changes & 1 && state.config?.iterateOptimizer) {
       continue;
     }
@@ -16154,9 +16255,9 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
   delete state.pre;
   delete state.post;
   if (state.config?.minimizeModules ?? true) {
-    Object.values(fnMap).forEach((f) => {
-      minimizeModules(f.ast, state);
-    });
+    for (const f of Object.values(fnMap)) {
+      await minimizeModules(f.ast, state);
+    }
   }
   await Object.values(state.allFunctions).reduce(
     (promise, fns) => fns.reduce(
@@ -16165,9 +16266,9 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
     ),
     Promise.resolve()
   );
-  cleanupAll(state);
+  await cleanupAll(state);
   config.checkCompilerLookupRules = checkLookupRules;
-  reportMissingSymbols(state, config);
+  await reportMissingSymbols(state, config);
   Object.values(fnMap).forEach(
     ({ ast }) => ast && reportFailedInlining(state, ast)
   );
@@ -16325,10 +16426,16 @@ function cleanup(state, node, ast, usedNodes) {
       }
       return typedefDecl;
     }
-    case "VariableDeclarator": {
-      const name = variableDeclarationName(node.id);
-      return !(0, import_chunk_UBAYZSM3.hasProperty)(state.index, name) || (0, import_chunk_UBAYZSM3.hasProperty)(state.exposed, name) || (0, import_chunk_UBAYZSM3.hasProperty)(state.usedByName, name) ? null : false;
-    }
+    case "VariableDeclarator":
+      if (state.stack.at(-1)?.sn.type !== "BlockStatement") {
+        const name = variableDeclarationName(node.id);
+        return !(0, import_chunk_UBAYZSM3.hasProperty)(state.index, name) || (0, import_chunk_UBAYZSM3.hasProperty)(state.exposed, name) || (0, import_chunk_UBAYZSM3.hasProperty)(state.usedByName, name) || !state.index[name].find(
+          (sn) => sn.decls?.[name]?.find(
+            (sn2) => sn2.type === "VariableDeclarator" && sn2.node === node
+          )
+        ) ? null : false;
+      }
+      break;
     case "VariableDeclaration": {
       if (!node.declarations.length) {
         return false;
@@ -17102,7 +17209,7 @@ function visitorNode(node) {
   }
   return node;
 }
-function visitReferences(state, ast, name, defn, callback, includeDefs = false, filter = null, typeMap = null, findSingleDefinition = false) {
+async function visitReferences(state, ast, name, defn, callback, includeDefs = false, filter = null, typeMap = null, findSingleDefinition = false) {
   const lookup2 = (node, nonLocal = false) => lookupWithType(state, node, typeMap, nonLocal);
   const checkResults = ([name2, results], node) => {
     if (name2 && results) {
@@ -17232,6 +17339,11 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
           }
           break;
         }
+        case "TypeSpecPart":
+          if (node.callspec) {
+            return ["callspec"];
+          }
+          break;
         case "MethodDefinition": {
           if (!this.inType) {
             throw new Error("Method definition outside of type!");
@@ -17300,7 +17412,7 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
       return null;
     };
     delete state.post;
-    collectNamespaces(ast, state);
+    return collectNamespaces(ast, state);
   } finally {
     state.pre = pre;
     state.post = post;
@@ -17378,9 +17490,9 @@ async function getApiMapping(state, resourcesMap, manifestXML) {
       state.manifestXML = manifestXML;
     }
   }
-  const result = collectNamespaces(ast, state);
+  const result = await collectNamespaces(ast, state);
   if (state && state.rezAst) {
-    collectNamespaces(state.rezAst, state);
+    await collectNamespaces(state.rezAst, state);
   }
   negativeFixups.forEach((fixup) => {
     const vs = fixup.split(".").reduce((state2, part) => {
@@ -18190,7 +18302,7 @@ function stateFuncs() {
     }
   };
 }
-function collectNamespaces(ast, stateIn) {
+async function collectNamespaces(ast, stateIn) {
   const state = stateIn || {};
   if (!state.nextExposed) state.nextExposed = {};
   if (!state.index) state.index = {};
@@ -18228,6 +18340,7 @@ function collectNamespaces(ast, stateIn) {
   }
   state.inType = 0;
   state.traverse(ast);
+  await import_chunk_IJS7AYMN.logPromise;
   if (state.inType) {
     throw new Error(`inType was non-zero on exit: ${state.inType}`);
   }
@@ -26897,24 +27010,31 @@ function getConfig(options) {
   const defaults = buildConfigDescription.flatMap(
     (desc) => Object.entries(desc.properties)
   );
-  return defaults.reduce((promise, [key, info]) => {
-    if (key in config) return promise;
-    return promise.then(
-      (v) => v || getVSCodeSettings(`${appSupport}/Code/User/settings.json`).then(
-        (globals) => getCodeWorkspaceSettings(config.workspace).then(
-          (workspace) => getVSCodeSettings(
-            `${config.workspace ?? "."}/.vscode/settings.json`
-          ).then((locals) => ({ ...globals, ...workspace, ...locals }))
+  return defaults.reduce(
+    (promise, [key, info]) => {
+      if (key in config) return promise;
+      return promise.then(
+        (v) => v || getVSCodeSettings(`${appSupport}/Code/User/settings.json`).then(
+          (globals) => getCodeWorkspaceSettings(config.workspace).then(
+            (workspace) => getVSCodeSettings(
+              `${config.workspace ?? "."}/.vscode/settings.json`
+            ).then((locals) => ({
+              ...globals,
+              ...workspace,
+              ...locals
+            }))
+          )
         )
-      )
-    ).then((settings) => {
-      const value2 = settings[`prettierMonkeyC.${key}`] ?? settings[`monkeyC.${key}`] ?? info.default;
-      if (value2 !== void 0) {
-        config[key] = value2;
-      }
-      return settings;
-    });
-  }, Promise.resolve(options.ignore_settings_files ? {} : null)).then((settings) => {
+      ).then((settings) => {
+        const value2 = settings[`prettierMonkeyC.${key}`] ?? settings[`monkeyC.${key}`] ?? info.default;
+        if (value2 !== void 0) {
+          config[key] = value2;
+        }
+        return settings;
+      });
+    },
+    Promise.resolve(options.ignore_settings_files ? {} : null)
+  ).then((settings) => {
     if (settings && (!config.strictTypeCheck || config.strictTypeCheck === "Default") && (settings["monkeyC.typeCheckLevel"]?.toString().toLowerCase() === "strict" || settings["prettierMonkeyC.typeCheckLevel"]?.toString().toLowerCase() === "strict")) {
       config.strictTypeCheck = "On";
     }
@@ -27172,12 +27292,15 @@ async function generateOptimizedProject(options) {
     const nextAvailableDefault = () => {
       if (!availableDefaults) {
         availableDefaults = Object.keys(
-          Object.values(devices).reduce((m, d) => {
-            m[d.deviceFamily] = true;
-            const match = d.deviceFamily.match(/^(\w+)-\d+x\d+/);
-            if (match) m[match[1]] = true;
-            return m;
-          }, {})
+          Object.values(devices).reduce(
+            (m, d) => {
+              m[d.deviceFamily] = true;
+              const match = d.deviceFamily.match(/^(\w+)-\d+x\d+/);
+              if (match) m[match[1]] = true;
+              return m;
+            },
+            {}
+          )
         ).sort();
         availableDefaults.unshift("base");
       }
@@ -27443,7 +27566,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_IJS7AYMN.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1772064318337 < opt_time) {
+      if (source_time < opt_time && 1773622846769 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -27481,7 +27604,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.96",
+            optimizerVersion: "1.1.97",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -27543,18 +27666,21 @@ async function getProjectAnalysisHelper(targets, analysis, manifestXML, options)
       )
     )
   ).then(
-    (results) => results.reduce((cur, result) => {
-      if (!cur) return result;
-      Object.entries(result.fnMap).forEach(([key, value2]) => {
-        if (cur.fnMap[key]) {
-          cur.fnMap[key + "::" + value2.barrel] = value2;
-        } else {
-          cur.fnMap[key] = value2;
-        }
-      });
-      cur.paths.push(...result.paths);
-      return cur;
-    }, null)
+    (results) => results.reduce(
+      (cur, result) => {
+        if (!cur) return result;
+        Object.entries(result.fnMap).forEach(([key, value2]) => {
+          if (cur.fnMap[key]) {
+            cur.fnMap[key + "::" + value2.barrel] = value2;
+          } else {
+            cur.fnMap[key] = value2;
+          }
+        });
+        cur.paths.push(...result.paths);
+        return cur;
+      },
+      null
+    )
   ).then(
     (result) => result ?? Promise.reject(
       new Error(
@@ -27597,7 +27723,7 @@ async function getProjectAnalysisHelper(targets, analysis, manifestXML, options)
 async function getFnMapAnalysis(fnMap, resourcesMap, manifestXML, options) {
   const state = await analyze(fnMap, resourcesMap, manifestXML, options, true);
   if (Object.values(fnMap).every(({ ast }) => ast != null)) {
-    reportMissingSymbols(state, options);
+    await reportMissingSymbols(state, options);
   }
   const typeMap = await analyze_module_types(state);
   const diagnostics = state.diagnostics && await resolveDiagnosticsMap(state.diagnostics);

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_4C4RQPFP.StateNodeAttributes,
-  buildConfigDescription: () => import_chunk_4C4RQPFP.buildConfigDescription,
-  buildOptimizedProject: () => import_chunk_4C4RQPFP.buildOptimizedProject,
+  StateNodeAttributes: () => import_chunk_WP3SDGBT.StateNodeAttributes,
+  buildConfigDescription: () => import_chunk_WP3SDGBT.buildConfigDescription,
+  buildOptimizedProject: () => import_chunk_WP3SDGBT.buildOptimizedProject,
   copyRecursiveAsNeeded: () => import_chunk_IJS7AYMN.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_4C4RQPFP.defaultConfig,
-  display: () => import_chunk_4C4RQPFP.display,
-  generateOneConfig: () => import_chunk_4C4RQPFP.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_4C4RQPFP.generateOptimizedProject,
-  getConfig: () => import_chunk_4C4RQPFP.getConfig,
-  getFnMapAnalysis: () => import_chunk_4C4RQPFP.getFnMapAnalysis,
-  getProjectAnalysis: () => import_chunk_4C4RQPFP.getProjectAnalysis,
-  get_jungle: () => import_chunk_4C4RQPFP.get_jungle,
-  isErrorWithLocation: () => import_chunk_4C4RQPFP.isErrorWithLocation,
-  launchSimulator: () => import_chunk_4C4RQPFP.launchSimulator,
-  manifestProducts: () => import_chunk_4C4RQPFP.manifestProducts,
-  mctree: () => import_chunk_4C4RQPFP.mctree,
-  simulateProgram: () => import_chunk_4C4RQPFP.simulateProgram
+  defaultConfig: () => import_chunk_WP3SDGBT.defaultConfig,
+  display: () => import_chunk_WP3SDGBT.display,
+  generateOneConfig: () => import_chunk_WP3SDGBT.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_WP3SDGBT.generateOptimizedProject,
+  getConfig: () => import_chunk_WP3SDGBT.getConfig,
+  getFnMapAnalysis: () => import_chunk_WP3SDGBT.getFnMapAnalysis,
+  getProjectAnalysis: () => import_chunk_WP3SDGBT.getProjectAnalysis,
+  get_jungle: () => import_chunk_WP3SDGBT.get_jungle,
+  isErrorWithLocation: () => import_chunk_WP3SDGBT.isErrorWithLocation,
+  launchSimulator: () => import_chunk_WP3SDGBT.launchSimulator,
+  manifestProducts: () => import_chunk_WP3SDGBT.manifestProducts,
+  mctree: () => import_chunk_WP3SDGBT.mctree,
+  simulateProgram: () => import_chunk_WP3SDGBT.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_4C4RQPFP = require("./chunk-4C4RQPFP.cjs");
+var import_chunk_WP3SDGBT = require("./chunk-WP3SDGBT.cjs");
 var import_chunk_IJS7AYMN = require("./chunk-IJS7AYMN.cjs");
 var import_chunk_UBAYZSM3 = require("./chunk-UBAYZSM3.cjs");
 var import_chunk_VS2QQHAK = require("./chunk-VS2QQHAK.cjs");
-(0, import_chunk_4C4RQPFP.init_optimizer)();
+(0, import_chunk_WP3SDGBT.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_4C4RQPFP.SectionKinds,
-  appSupport: () => import_chunk_4C4RQPFP.appSupport,
-  connectiq: () => import_chunk_4C4RQPFP.connectiq,
-  getDeviceInfo: () => import_chunk_4C4RQPFP.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_4C4RQPFP.getFunctionDocumentation,
-  getLanguages: () => import_chunk_4C4RQPFP.getLanguages,
-  getSdkPath: () => import_chunk_4C4RQPFP.getSdkPath,
-  isWin: () => import_chunk_4C4RQPFP.isWin,
-  optimizeProgram: () => import_chunk_4C4RQPFP.optimizeProgram,
-  readPrg: () => import_chunk_4C4RQPFP.readPrg,
-  readPrgWithOffsets: () => import_chunk_4C4RQPFP.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_4C4RQPFP.xml_util_exports
+  SectionKinds: () => import_chunk_WP3SDGBT.SectionKinds,
+  appSupport: () => import_chunk_WP3SDGBT.appSupport,
+  connectiq: () => import_chunk_WP3SDGBT.connectiq,
+  getDeviceInfo: () => import_chunk_WP3SDGBT.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_WP3SDGBT.getFunctionDocumentation,
+  getLanguages: () => import_chunk_WP3SDGBT.getLanguages,
+  getSdkPath: () => import_chunk_WP3SDGBT.getSdkPath,
+  isWin: () => import_chunk_WP3SDGBT.isWin,
+  optimizeProgram: () => import_chunk_WP3SDGBT.optimizeProgram,
+  readPrg: () => import_chunk_WP3SDGBT.readPrg,
+  readPrgWithOffsets: () => import_chunk_WP3SDGBT.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_WP3SDGBT.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_4C4RQPFP = require("./chunk-4C4RQPFP.cjs");
+var import_chunk_WP3SDGBT = require("./chunk-WP3SDGBT.cjs");
 var import_chunk_IJS7AYMN = require("./chunk-IJS7AYMN.cjs");
 var import_chunk_UBAYZSM3 = require("./chunk-UBAYZSM3.cjs");
 var import_chunk_VS2QQHAK = require("./chunk-VS2QQHAK.cjs");
-(0, import_chunk_4C4RQPFP.init_sdk_util)();
+(0, import_chunk_WP3SDGBT.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/api.d.ts

@@ -25,13 +25,13 @@ export declare function isLookupCandidate(node: mctree.MemberExpression): false
 export declare function lookupNext(state: ProgramStateLive, results: LookupDefinition[], decls: DeclKind, property: mctree.Identifier): LookupDefinition[] | null;
 export declare function lookupWithType(state: ProgramStateAnalysis, node: mctree.Node, typeMap: TypeMap | undefined | null, nonLocal?: boolean, stack?: ProgramStateStack | null): LookupResult;
 export declare function handleImportUsing(state: ProgramStateLive, node: mctree.Using | mctree.ImportModule): void;
-export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
+export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): Promise<ProgramStateNode>;
 export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null, options?: Record<string, unknown> | null): Promise<string>;
 export declare function findNamesInScope(declStack: StateNode[][], pattern: string | RegExp): (readonly [StateNodeDecl, {
     readonly parent: StateNode;
     readonly depth: number;
 }])[];
-export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | ProgramStateNode | FunctionStateNode | ModuleStateNode | ClassStateNode | TypedefStateNode | VariableStateNode | EnumStateNode | import("./optimizer-types").BlockStateNode)[];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | ProgramStateNode | FunctionStateNode | ModuleStateNode | ClassStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | VariableStateNode | EnumStateNode)[];
 export declare function formatScopedName(node: mctree.ScopedName | mctree.ThisExpression): string;
 export declare function formatAstLongLines(node: mctree.Node): Promise<string>;
 export declare function createDocumentationMap(functionDocumentation: {

package/build/src/mc-rewrite.d.ts

@@ -5,7 +5,7 @@ import { xmlUtil } from "./sdk-util";
 export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
 export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
 export declare function analyze(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document | undefined, config: BuildConfig, allowParseErrors?: boolean): Promise<ProgramStateAnalysis>;
-export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): void;
+export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): Promise<void>;
 export declare function getLiteralFromDecls(lookupDefns: LookupDefinition[]): mctree.Literal | mctree.AsExpression | null;
 export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document, config: BuildConfig): Promise<{
     diagnostics: Record<string, Diagnostic[]> | undefined;

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

@@ -179,7 +179,7 @@ export type ProgramState = {
         };
     }[];
     index?: {
-        [key: string]: unknown[];
+        [key: string]: StateNode[];
     };
     constants?: {
         [key: string]: mctree.Literal;

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

@@ -27,6 +27,7 @@ export type InterpState = {
     checkTypes?: DiagnosticType;
     dependencies?: DependencyMap;
     frpushType?: ExactOrUnion;
+    rerun?: true;
 };
 export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
 export declare function tryPop(istate: InterpState, node: InterpStackElem["node"]): InterpStackElem;

package/build/src/type-flow/minimize-modules.d.ts

@@ -1,3 +1,3 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { ProgramStateAnalysis } from "../optimizer-types";
-export declare function minimizeModules(ast: mctree.Program, state: ProgramStateAnalysis): void;
+export declare function minimizeModules(ast: mctree.Program, state: ProgramStateAnalysis): Promise<void>;

package/build/src/visitor.d.ts

@@ -2,4 +2,4 @@ import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 import { TypeMap } from "./type-flow/interp";
 export declare function visitorNode(node: mctree.Node): mctree.Node;
-export declare function visitReferences(state: ProgramStateAnalysis, ast: mctree.Program, name: string | null, defn: LookupDefinition[] | null | false, callback: (node: mctree.Node, results: LookupDefinition[], error: boolean) => undefined | false, includeDefs?: boolean, filter?: ((node: mctree.Node) => boolean) | null, typeMap?: TypeMap | null, findSingleDefinition?: boolean): void;
+export declare function visitReferences(state: ProgramStateAnalysis, ast: mctree.Program, name: string | null, defn: LookupDefinition[] | null | false, callback: (node: mctree.Node, results: LookupDefinition[], error: boolean) => undefined | false, includeDefs?: boolean, filter?: ((node: mctree.Node) => boolean) | null, typeMap?: TypeMap | null, findSingleDefinition?: boolean): Promise<import("./optimizer-types").ProgramStateNode>;

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_4C4RQPFP = require("./chunk-4C4RQPFP.cjs");
+var import_chunk_WP3SDGBT = require("./chunk-WP3SDGBT.cjs");
 var import_chunk_IJS7AYMN = require("./chunk-IJS7AYMN.cjs");
 var import_chunk_UBAYZSM3 = require("./chunk-UBAYZSM3.cjs");
 var import_chunk_VS2QQHAK = require("./chunk-VS2QQHAK.cjs");
 var import_node_worker_threads = require("node:worker_threads");
 var require_worker_thread = (0, import_chunk_VS2QQHAK.__commonJS)({
   "src/worker-thread.ts"() {
-    (0, import_chunk_4C4RQPFP.init_worker_task)();
+    (0, import_chunk_WP3SDGBT.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_4C4RQPFP.performTask)(task));
+        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_WP3SDGBT.performTask)(task));
       });
     }
   }

package/package.json

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