@markw65/monkeyc-optimizer 1.1.28 → 1.1.29

package/README.md

@@ -887,3 +887,12 @@ No functional change, just fixes a typo that broke the typescript exports.
 
 - Improved optimizations
   - Constant folding between `Char` and types other than `Number` is now handled (previously such comparisons were just left for Garmin's compiler to handle). This works around a [bug in Garmin's optimizer](https://forums.garmin.com/developer/connect-iq/i/bug-reports/the-optimizer-constant-folds-char-comparisons-incorrectly) by (correctly) resolving the comparisons before Garmin's optimizer can do the wrong thing.
+
+### 1.1.29
+
+- Bug fixes
+
+  - Fixes an issue where a value could incorrectly be inferred to be true-ish when its declared type was known to be an object of class type. This is not of itself incorrect, but some Toybox APIs are declared as returning an Object of a class, but may in fact return null - so we can't treat them as non-null.
+
+- Enhancements
+  - various methods used by the extension for completion and hover info have been updated to give more accurate results.

package/build/api.cjs

@@ -18,44 +18,44 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  checkCompilerVersion: () => import_chunk_ZI7CGRJC.checkCompilerVersion,
-  collectNamespaces: () => import_chunk_ZI7CGRJC.collectNamespaces,
-  createDocumentationMap: () => import_chunk_ZI7CGRJC.createDocumentationMap,
-  diagnostic: () => import_chunk_ZI7CGRJC.diagnostic,
-  diagnosticHelper: () => import_chunk_ZI7CGRJC.diagnosticHelper,
-  findNamesInScope: () => import_chunk_ZI7CGRJC.findNamesInScope,
-  findUsingForNode: () => import_chunk_ZI7CGRJC.findUsingForNode,
-  formatAst: () => import_chunk_ZI7CGRJC.formatAst,
-  formatAstLongLines: () => import_chunk_ZI7CGRJC.formatAstLongLines,
-  getApiFunctionInfo: () => import_chunk_ZI7CGRJC.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_ZI7CGRJC.getApiMapping,
-  getSuperClasses: () => import_chunk_ZI7CGRJC.getSuperClasses,
+  checkCompilerVersion: () => import_chunk_PUYLJGKM.checkCompilerVersion,
+  collectNamespaces: () => import_chunk_PUYLJGKM.collectNamespaces,
+  createDocumentationMap: () => import_chunk_PUYLJGKM.createDocumentationMap,
+  diagnostic: () => import_chunk_PUYLJGKM.diagnostic,
+  diagnosticHelper: () => import_chunk_PUYLJGKM.diagnosticHelper,
+  findNamesInScope: () => import_chunk_PUYLJGKM.findNamesInScope,
+  findUsingForNode: () => import_chunk_PUYLJGKM.findUsingForNode,
+  formatAst: () => import_chunk_PUYLJGKM.formatAst,
+  formatAstLongLines: () => import_chunk_PUYLJGKM.formatAstLongLines,
+  getApiFunctionInfo: () => import_chunk_PUYLJGKM.getApiFunctionInfo,
+  getApiMapping: () => import_chunk_PUYLJGKM.getApiMapping,
+  getSuperClasses: () => import_chunk_PUYLJGKM.getSuperClasses,
   hasProperty: () => import_chunk_MBTLUWXR.hasProperty,
-  isClassVariable: () => import_chunk_ZI7CGRJC.isClassVariable,
-  isLocal: () => import_chunk_ZI7CGRJC.isLocal,
-  isLookupCandidate: () => import_chunk_ZI7CGRJC.isLookupCandidate,
-  isStateNode: () => import_chunk_ZI7CGRJC.isStateNode,
-  lookupByFullName: () => import_chunk_ZI7CGRJC.lookupByFullName,
-  lookupNext: () => import_chunk_ZI7CGRJC.lookupNext,
-  lookupResultContains: () => import_chunk_ZI7CGRJC.lookupResultContains,
-  lookupWithType: () => import_chunk_ZI7CGRJC.lookupWithType,
-  makeToyboxLink: () => import_chunk_ZI7CGRJC.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_ZI7CGRJC.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_ZI7CGRJC.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_ZI7CGRJC.parseSdkVersion,
-  sameLookupResult: () => import_chunk_ZI7CGRJC.sameLookupResult,
+  isClassVariable: () => import_chunk_PUYLJGKM.isClassVariable,
+  isLocal: () => import_chunk_PUYLJGKM.isLocal,
+  isLookupCandidate: () => import_chunk_PUYLJGKM.isLookupCandidate,
+  isStateNode: () => import_chunk_PUYLJGKM.isStateNode,
+  lookupByFullName: () => import_chunk_PUYLJGKM.lookupByFullName,
+  lookupNext: () => import_chunk_PUYLJGKM.lookupNext,
+  lookupResultContains: () => import_chunk_PUYLJGKM.lookupResultContains,
+  lookupWithType: () => import_chunk_PUYLJGKM.lookupWithType,
+  makeToyboxLink: () => import_chunk_PUYLJGKM.makeToyboxLink,
+  mapVarDeclsByType: () => import_chunk_PUYLJGKM.mapVarDeclsByType,
+  markInvokeClassMethod: () => import_chunk_PUYLJGKM.markInvokeClassMethod,
+  parseSdkVersion: () => import_chunk_PUYLJGKM.parseSdkVersion,
+  sameLookupResult: () => import_chunk_PUYLJGKM.sameLookupResult,
   traverseAst: () => import_chunk_MBTLUWXR.traverseAst,
-  variableDeclarationName: () => import_chunk_ZI7CGRJC.variableDeclarationName,
-  visitReferences: () => import_chunk_ZI7CGRJC.visitReferences,
-  visit_resources: () => import_chunk_ZI7CGRJC.visit_resources,
-  visitorNode: () => import_chunk_ZI7CGRJC.visitorNode
+  variableDeclarationName: () => import_chunk_PUYLJGKM.variableDeclarationName,
+  visitReferences: () => import_chunk_PUYLJGKM.visitReferences,
+  visit_resources: () => import_chunk_PUYLJGKM.visit_resources,
+  visitorNode: () => import_chunk_PUYLJGKM.visitorNode
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_ZI7CGRJC = require("./chunk-ZI7CGRJC.cjs");
+var import_chunk_PUYLJGKM = require("./chunk-PUYLJGKM.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_ZI7CGRJC.init_api)();
+(0, import_chunk_PUYLJGKM.init_api)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,

package/build/{chunk-ZI7CGRJC.cjs → chunk-PUYLJGKM.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_ZI7CGRJC_exports = {};
-__export(chunk_ZI7CGRJC_exports, {
+var chunk_PUYLJGKM_exports = {};
+__export(chunk_PUYLJGKM_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -122,7 +122,7 @@ __export(chunk_ZI7CGRJC_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_ZI7CGRJC_exports);
+module.exports = __toCommonJS(chunk_PUYLJGKM_exports);
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -10768,6 +10768,7 @@ function filterDecls(decls, possible, name) {
     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]) {
@@ -10776,12 +10777,27 @@ function filterDecls(decls, possible, name) {
           cur[0].add(poss);
           cur[1].add(poss);
           return true;
-        } else if (decl.type === "ClassDeclaration" && getSuperClasses(decl)?.has(poss)) {
+        } else if (declSups !== void 0 ? declSups?.has(poss) : decl.type === "ClassDeclaration" && (declSups = getSuperClasses(decl))?.has(poss)) {
           if (!cur[0]) {
-            cur = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+            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);
+            }
           }
-          cur[0].add(decl);
-          cur[1].add(poss);
           return true;
         }
         return flag;
@@ -13174,7 +13190,8 @@ var init_types = (0, import_chunk_ABYVSU2C.__esm)({
     ValueTypeTagsConst = 8 | 16 | 32 | 64 | 128 | 256 | 131072;
     ObjectLikeTagsConst = 6 | ValueTypeTagsConst | 512 | 1024 | 2048 | 65536;
     EnumTagsConst = SingletonTypeTagsConst | ValueTypeTagsConst & ~131072;
-    TruthyTypes = 4 | 32768 | 4096 | 16384 | 8192;
+    TruthyTypes = 4 | // TypeTag.Object | // omit because of missing null on various Toybox types
+    4096 | 16384 | 8192;
   }
 });
 function couldBeHelper(a, b, shallow) {
@@ -19533,6 +19550,20 @@ function lookupWithType(state, node, typeMap, nonLocal = false, stack = null) {
         return [node.property.name, next];
       }
     }
+  } else if (node.type === "Literal") {
+    const type = typeFromLiteral(node);
+    const results2 = getStateNodeDeclsFromType(state, type);
+    return [node.raw, [{ parent: null, results: results2 }]];
+  } else if (node.type === "UnaryExpression" && node.operator === ":") {
+    return [
+      node.argument.name,
+      [
+        {
+          parent: null,
+          results: lookupByFullName(state, "Toybox.Lang.Symbol")
+        }
+      ]
+    ];
   }
   return results;
 }
@@ -19993,7 +20024,7 @@ function findNamesInExactScope(decl, regexp) {
   if (!decl.decls)
     return [];
   return Object.entries(decl.decls).flatMap(
-    ([key, value2]) => regexp.test(key) ? value2 : []
+    ([name, decls]) => regexp.test(name) ? { name, decls } : []
   );
 }
 function findNamesInScope(declStack, pattern) {
@@ -20003,11 +20034,18 @@ function findNamesInScope(declStack, pattern) {
     decls.forEach((parent) => {
       if (parent.type === "ClassDeclaration") {
         if (parent.superClass && parent.superClass !== true) {
-          helper(parent.superClass, depth2 + 1);
+          helper(parent.superClass, depth2);
         }
       }
-      findNamesInExactScope(parent, regex).forEach((sn) => {
-        results.set(sn, { parent, depth: depth2 });
+      findNamesInExactScope(parent, regex).forEach(({ name, decls: decls2 }) => {
+        let names = results.get(name);
+        if (!names) {
+          results.set(name, names = /* @__PURE__ */ new Map());
+        }
+        names.set(
+          depth2,
+          decls2.map((decl) => ({ decl, parent }))
+        );
       });
     });
   };
@@ -20016,7 +20054,11 @@ function findNamesInScope(declStack, pattern) {
     helper(declStack[declStack.length - 1 - depth], depth);
     depth++;
   }
-  return Array.from(results);
+  return Array.from(results.values()).map(
+    (m) => Array.from(m).map(
+      ([depth2, entries]) => entries.map(({ decl, parent }) => [decl, { parent, depth: depth2 }])
+    )
+  ).flat(2);
 }
 function mapVarDeclsByType(state, decls, node, typeMap) {
   return decls.flatMap((decl) => {
@@ -29802,7 +29844,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
     const opt_time = await (0, import_chunk_PVBIKZYZ.first_modified)(
       Object.values(fnMap).map((v) => v.output)
     );
-    if (source_time < opt_time && 1684251991147 < opt_time) {
+    if (source_time < opt_time && 1685575802667 < opt_time) {
       return {
         hasTests,
         diagnostics: prevDiagnostics,
@@ -29839,7 +29881,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.28",
+            optimizerVersion: "1.1.29",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )

package/build/optimizer.cjs

@@ -18,29 +18,29 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var optimizer_exports = {};
 __export(optimizer_exports, {
-  StateNodeAttributes: () => import_chunk_ZI7CGRJC.StateNodeAttributes,
-  buildOptimizedProject: () => import_chunk_ZI7CGRJC.buildOptimizedProject,
+  StateNodeAttributes: () => import_chunk_PUYLJGKM.StateNodeAttributes,
+  buildOptimizedProject: () => import_chunk_PUYLJGKM.buildOptimizedProject,
   copyRecursiveAsNeeded: () => import_chunk_PVBIKZYZ.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_ZI7CGRJC.defaultConfig,
-  display: () => import_chunk_ZI7CGRJC.display,
-  generateApiMirTests: () => import_chunk_ZI7CGRJC.generateApiMirTests,
-  generateOneConfig: () => import_chunk_ZI7CGRJC.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_ZI7CGRJC.generateOptimizedProject,
-  getConfig: () => import_chunk_ZI7CGRJC.getConfig,
-  getProjectAnalysis: () => import_chunk_ZI7CGRJC.getProjectAnalysis,
-  get_jungle: () => import_chunk_ZI7CGRJC.get_jungle,
-  isErrorWithLocation: () => import_chunk_ZI7CGRJC.isErrorWithLocation,
-  launchSimulator: () => import_chunk_ZI7CGRJC.launchSimulator,
-  manifestProducts: () => import_chunk_ZI7CGRJC.manifestProducts,
-  mctree: () => import_chunk_ZI7CGRJC.mctree,
-  simulateProgram: () => import_chunk_ZI7CGRJC.simulateProgram
+  defaultConfig: () => import_chunk_PUYLJGKM.defaultConfig,
+  display: () => import_chunk_PUYLJGKM.display,
+  generateApiMirTests: () => import_chunk_PUYLJGKM.generateApiMirTests,
+  generateOneConfig: () => import_chunk_PUYLJGKM.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_PUYLJGKM.generateOptimizedProject,
+  getConfig: () => import_chunk_PUYLJGKM.getConfig,
+  getProjectAnalysis: () => import_chunk_PUYLJGKM.getProjectAnalysis,
+  get_jungle: () => import_chunk_PUYLJGKM.get_jungle,
+  isErrorWithLocation: () => import_chunk_PUYLJGKM.isErrorWithLocation,
+  launchSimulator: () => import_chunk_PUYLJGKM.launchSimulator,
+  manifestProducts: () => import_chunk_PUYLJGKM.manifestProducts,
+  mctree: () => import_chunk_PUYLJGKM.mctree,
+  simulateProgram: () => import_chunk_PUYLJGKM.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_ZI7CGRJC = require("./chunk-ZI7CGRJC.cjs");
+var import_chunk_PUYLJGKM = require("./chunk-PUYLJGKM.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_ZI7CGRJC.init_optimizer)();
+(0, import_chunk_PUYLJGKM.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_ZI7CGRJC.SectionKinds,
-  appSupport: () => import_chunk_ZI7CGRJC.appSupport,
-  connectiq: () => import_chunk_ZI7CGRJC.connectiq,
-  getDeviceInfo: () => import_chunk_ZI7CGRJC.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_ZI7CGRJC.getFunctionDocumentation,
-  getLanguages: () => import_chunk_ZI7CGRJC.getLanguages,
-  getSdkPath: () => import_chunk_ZI7CGRJC.getSdkPath,
-  isWin: () => import_chunk_ZI7CGRJC.isWin,
-  optimizeProgram: () => import_chunk_ZI7CGRJC.optimizeProgram,
-  readPrg: () => import_chunk_ZI7CGRJC.readPrg,
-  readPrgWithOffsets: () => import_chunk_ZI7CGRJC.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_ZI7CGRJC.xml_util_exports
+  SectionKinds: () => import_chunk_PUYLJGKM.SectionKinds,
+  appSupport: () => import_chunk_PUYLJGKM.appSupport,
+  connectiq: () => import_chunk_PUYLJGKM.connectiq,
+  getDeviceInfo: () => import_chunk_PUYLJGKM.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_PUYLJGKM.getFunctionDocumentation,
+  getLanguages: () => import_chunk_PUYLJGKM.getLanguages,
+  getSdkPath: () => import_chunk_PUYLJGKM.getSdkPath,
+  isWin: () => import_chunk_PUYLJGKM.isWin,
+  optimizeProgram: () => import_chunk_PUYLJGKM.optimizeProgram,
+  readPrg: () => import_chunk_PUYLJGKM.readPrg,
+  readPrgWithOffsets: () => import_chunk_PUYLJGKM.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_PUYLJGKM.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_ZI7CGRJC = require("./chunk-ZI7CGRJC.cjs");
+var import_chunk_PUYLJGKM = require("./chunk-PUYLJGKM.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_ZI7CGRJC.init_sdk_util)();
+(0, import_chunk_PUYLJGKM.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/api.d.ts

@@ -22,10 +22,10 @@ export declare function lookupNext(state: ProgramStateLive, results: LookupDefin
 export declare function lookupWithType(state: ProgramStateAnalysis, node: mctree.Node, typeMap: TypeMap | undefined | null, nonLocal?: boolean, stack?: ProgramStateStack | null): LookupResult;
 export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
 export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null, options?: Record<string, unknown> | null): string;
-export declare function findNamesInScope(declStack: StateNode[][], pattern: string | RegExp): [StateNodeDecl, {
-    parent: StateNode;
-    depth: number;
-}][];
+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 | FunctionStateNode | ClassStateNode | ModuleStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | EnumStateNode)[];
 export declare function formatAstLongLines(node: mctree.Node): string;
 export declare function createDocumentationMap(functionDocumentation: {

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_ZI7CGRJC = require("./chunk-ZI7CGRJC.cjs");
+var import_chunk_PUYLJGKM = require("./chunk-PUYLJGKM.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.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_ZI7CGRJC.init_worker_task)();
+    (0, import_chunk_PUYLJGKM.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_ZI7CGRJC.performTask)(task));
+        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_PUYLJGKM.performTask)(task));
       });
     }
   }

package/package.json

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