@markw65/monkeyc-optimizer 1.1.26 → 1.1.28

package/README.md

@@ -854,7 +854,7 @@ No functional change, just fixes a typo that broke the typescript exports.
 - Bug fixes
 
   - fixes an issue in the post build optimizer which could cause pre variables to be inserted too late in a block that could throw (so that if the variable was used in, or after the catch block, it might not have been set).
-  - fixes an issue with references in resource files, that could result in result in some references not being reported to the extension (only affects `Goto References` and `Goto Definition`)
+  - fixes an issue with references in resource files, that could result in some references not being reported to the extension (only affects `Goto References` and `Goto Definition`)
   - fixes some issues converting the system function documentation to markdown (for the Hover, Completion and Signature providers in the extension).
 
 - New features
@@ -867,3 +867,23 @@ No functional change, just fixes a typo that broke the typescript exports.
 
 - Tests
   - Adds a new project to test `.mss` files, and references to personalities from `.mc` files
+
+### 1.1.27
+
+- Bug fixes
+
+  - Fixes an incorrect type check warning when an assignment to a local was incompatible with the type of a same-named non-local variable. This only affects the warning; it did not result in incorrect optimizations.
+
+- New features
+  - Adds a [standalone script](https://github.com/markw65/monkeyc-optimizer/wiki/Garmin-Font-Analyzer) to analyze .cft (font) files.
+
+### 1.1.28
+
+- Bug fixes
+
+  - Fixes an issue in the post build optimizer which could cause a pre-definition to be inserted just prior to an `frpush`, which could result in the wrong value of `self` being passed to a call
+  - Don't add personality paths to the generated jungle file if the sdk is prior to 4.2.1
+  - Fixes a bug in the source-to-source optimizer that could incorrectly infer that an `if` block was never entered when the if's comparison was between a primitive type, and a plain `Object`
+
+- 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.

package/bin/cft-font-info.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+const cft = require("../build/cftinfo.cjs");
+const sdkUtil = require("../build/sdk-util.cjs");
+const { globa } = require("../build/util.cjs");
+const path = require("node:path");
+
+const fonts = new Set();
+Promise.all(
+  process.argv.slice(2).map((filename) => {
+    if (/\.cft$/i.test(filename)) {
+      return globa(path.resolve(sdkUtil.connectiq, "Fonts", filename)).then(
+        (filenames) => {
+          filenames.forEach((fn) => fonts.add(fn));
+          return null;
+        }
+      );
+    }
+    return globa(path.resolve(sdkUtil.connectiq, "Devices", filename), {
+      mark: true,
+    }).then((devices) =>
+      Promise.all(
+        devices.map((device) => {
+          if (!device.endsWith("/")) return null;
+          return cft.getDeviceFontInfo(device).then((devInfo) => {
+            Object.values(devInfo.fontSets).forEach((fontSet) =>
+              Object.values(fontSet).forEach((file) =>
+                fonts.add(
+                  path.resolve(sdkUtil.connectiq, "Fonts", `${file}.cft`)
+                )
+              )
+            );
+            return devInfo;
+          });
+        })
+      )
+    );
+  })
+)
+  .then((results) =>
+    Promise.all(
+      Array.from(fonts).map((font) =>
+        cft.getCFTFontInfo(font).catch(() => null)
+      )
+    )
+      .then((fonts) =>
+        Object.fromEntries(
+          fonts
+            .filter((font) => font != null)
+            .map(({ name, ...rest }) => [name, rest])
+        )
+      )
+      .then((fonts) => ({
+        fonts,
+        devices: Object.fromEntries(
+          results
+            .flat()
+            .filter((result) => result != null)
+            .map(({ device, ...rest }) => [device, rest])
+        ),
+      }))
+  )
+  .then((results) => console.log(JSON.stringify(results)));

package/build/api.cjs

@@ -18,42 +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_XO53WBWQ.checkCompilerVersion,
-  collectNamespaces: () => import_chunk_XO53WBWQ.collectNamespaces,
-  createDocumentationMap: () => import_chunk_XO53WBWQ.createDocumentationMap,
-  diagnostic: () => import_chunk_XO53WBWQ.diagnostic,
-  diagnosticHelper: () => import_chunk_XO53WBWQ.diagnosticHelper,
-  findNamesInScope: () => import_chunk_XO53WBWQ.findNamesInScope,
-  findUsingForNode: () => import_chunk_XO53WBWQ.findUsingForNode,
-  formatAst: () => import_chunk_XO53WBWQ.formatAst,
-  formatAstLongLines: () => import_chunk_XO53WBWQ.formatAstLongLines,
-  getApiFunctionInfo: () => import_chunk_XO53WBWQ.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_XO53WBWQ.getApiMapping,
-  getSuperClasses: () => import_chunk_XO53WBWQ.getSuperClasses,
-  hasProperty: () => import_chunk_XO53WBWQ.hasProperty,
-  isClassVariable: () => import_chunk_XO53WBWQ.isClassVariable,
-  isLocal: () => import_chunk_XO53WBWQ.isLocal,
-  isLookupCandidate: () => import_chunk_XO53WBWQ.isLookupCandidate,
-  isStateNode: () => import_chunk_XO53WBWQ.isStateNode,
-  lookupByFullName: () => import_chunk_XO53WBWQ.lookupByFullName,
-  lookupNext: () => import_chunk_XO53WBWQ.lookupNext,
-  lookupResultContains: () => import_chunk_XO53WBWQ.lookupResultContains,
-  lookupWithType: () => import_chunk_XO53WBWQ.lookupWithType,
-  makeToyboxLink: () => import_chunk_XO53WBWQ.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_XO53WBWQ.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_XO53WBWQ.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_XO53WBWQ.parseSdkVersion,
-  sameLookupResult: () => import_chunk_XO53WBWQ.sameLookupResult,
-  traverseAst: () => import_chunk_XO53WBWQ.traverseAst,
-  variableDeclarationName: () => import_chunk_XO53WBWQ.variableDeclarationName,
-  visitReferences: () => import_chunk_XO53WBWQ.visitReferences,
-  visit_resources: () => import_chunk_XO53WBWQ.visit_resources,
-  visitorNode: () => import_chunk_XO53WBWQ.visitorNode
+  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,
+  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,
+  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
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_XO53WBWQ = require("./chunk-XO53WBWQ.cjs");
-var import_chunk_YZ44IUV6 = require("./chunk-YZ44IUV6.cjs");
-(0, import_chunk_XO53WBWQ.init_api)();
+var import_chunk_ZI7CGRJC = require("./chunk-ZI7CGRJC.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)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,

package/build/cftinfo.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cftinfo_exports = {};
+__export(cftinfo_exports, {
+  getCFTFontInfo: () => getCFTFontInfo,
+  getCFTFontInfoFromBuffer: () => getCFTFontInfoFromBuffer,
+  getDeviceFontInfo: () => getDeviceFontInfo
+});
+module.exports = __toCommonJS(cftinfo_exports);
+var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
+var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
+var import_node_assert = __toESM(require("node:assert"));
+var fs = __toESM(require("node:fs/promises"));
+var path = __toESM(require("node:path"));
+(0, import_chunk_MBTLUWXR.init_ast)();
+function getCFTFontInfoFromBuffer(name, data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const cmapOffset = view.getUint32(8);
+  const glyphInfoOffset = view.getUint32(12);
+  const height = view.getUint16(22);
+  const ascent = view.getUint16(24);
+  const internalLeading = view.getUint16(26);
+  const cmapNGroups = view.getUint32(cmapOffset + 12);
+  const charInfo = [];
+  for (let i = 0, offset = cmapOffset + 16; i < cmapNGroups; i++) {
+    const startChar = view.getUint32(offset + 0);
+    const endChar = view.getUint32(offset + 4);
+    const startGlyph = view.getUint32(offset + 8);
+    offset += 12;
+    for (let code = startChar, g = startGlyph; code <= endChar; code++, g++) {
+      const width = view.getUint8(glyphInfoOffset + g * 4 + 3);
+      charInfo.push({ code, char: String.fromCharCode(code), width });
+    }
+  }
+  return {
+    name,
+    height,
+    ascent,
+    internalLeading,
+    charInfo
+  };
+}
+function getCFTFontInfo(filename) {
+  return fs.readFile(filename).then((data) => {
+    const name = path.basename(filename, ".cft");
+    return getCFTFontInfoFromBuffer(name, data);
+  });
+}
+function getDeviceFontInfo(dirname) {
+  return Promise.all([
+    fs.readFile(path.resolve(dirname, "compiler.json"), "utf-8"),
+    fs.readFile(path.resolve(dirname, "simulator.json"), "utf-8")
+  ]).then(([compiler, simulator]) => {
+    const fonts = JSON.parse(simulator).fonts;
+    const fontSets = Object.fromEntries(
+      fonts.map(({ fontSet, fonts: fonts2 }) => [
+        fontSet,
+        Object.fromEntries(
+          fonts2.map(({ filename, name }) => [
+            "FONT_" + name.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase(),
+            filename
+          ])
+        )
+      ])
+    );
+    const partNumbers = JSON.parse(compiler).partNumbers;
+    const langMap = {};
+    partNumbers.map(
+      (part) => part.languages.map((lang) => {
+        (0, import_node_assert.default)((0, import_chunk_MBTLUWXR.hasProperty)(fontSets, lang.fontSet));
+        if ((0, import_chunk_MBTLUWXR.hasProperty)(langMap, lang.code)) {
+          (0, import_node_assert.default)(langMap[lang.code] === lang.fontSet);
+        } else {
+          langMap[lang.code] = lang.fontSet;
+        }
+      })
+    );
+    return { device: path.basename(dirname), fontSets, langMap };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCFTFontInfo,
+  getCFTFontInfoFromBuffer,
+  getDeviceFontInfo
+});

package/build/chunk-ABYVSU2C.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_ABYVSU2C_exports = {};
+__export(chunk_ABYVSU2C_exports, {
+  __commonJS: () => __commonJS,
+  __esm: () => __esm,
+  __export: () => __export2,
+  __require: () => __require,
+  __toESM: () => __toESM
+});
+module.exports = __toCommonJS(chunk_ABYVSU2C_exports);
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __commonJS,
+  __esm,
+  __export,
+  __require,
+  __toESM
+});