@markw65/monkeyc-optimizer 1.1.36 → 1.1.37

package/build/{chunk-PVBIKZYZ.cjs → chunk-SG7ODKRM.cjs}

@@ -26,8 +26,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_PVBIKZYZ_exports = {};
-__export(chunk_PVBIKZYZ_exports, {
+var chunk_SG7ODKRM_exports = {};
+__export(chunk_SG7ODKRM_exports, {
+  AwaitedError: () => AwaitedError,
   GenericQueue: () => GenericQueue,
   bumpLogging: () => bumpLogging,
   copyRecursiveAsNeeded: () => copyRecursiveAsNeeded,
@@ -40,6 +41,7 @@ __export(chunk_PVBIKZYZ_exports, {
   init_util: () => init_util,
   last_modified: () => last_modified,
   log: () => log,
+  logPromise: () => logPromise,
   logger: () => logger,
   map: () => map,
   popcount: () => popcount,
@@ -53,7 +55,7 @@ __export(chunk_PVBIKZYZ_exports, {
   spawnByLine: () => spawnByLine,
   wouldLog: () => wouldLog
 });
-module.exports = __toCommonJS(chunk_PVBIKZYZ_exports);
+module.exports = __toCommonJS(chunk_SG7ODKRM_exports);
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
 var child_process = __toESM(require("child_process"));
 var fsc = __toESM(require("fs"));
@@ -5442,17 +5444,31 @@ function bumpLogging(module2, amount) {
 function setBanner(b) {
   banner = b;
 }
-function log(message) {
+function log(...messages) {
   if (banner) {
     const b = banner;
     banner = null;
     theLogger(b());
   }
-  if (theLogger === console.log) {
-    theLogger(message);
-  } else {
-    theLogger(`${message}`);
-  }
+  messages.forEach((message) => {
+    if (livePromises || message.then) {
+      livePromises++;
+      logPromise = logPromise.then(() => Promise.resolve(message)).then((m) => {
+        livePromises--;
+        if (theLogger === console.log) {
+          theLogger(m);
+        } else {
+          theLogger(`${m}`);
+        }
+      });
+    } else {
+      if (theLogger === console.log) {
+        theLogger(message);
+      } else {
+        theLogger(`${message}`);
+      }
+    }
+  });
 }
 function getLoggerSettings() {
   const ls = /* @__PURE__ */ new Map();
@@ -5469,7 +5485,7 @@ function getLoggerSettings() {
   }
   return ls;
 }
-var loggerSettings, loggerLevelOffset, theLogger, banner;
+var loggerSettings, loggerLevelOffset, theLogger, banner, logPromise, livePromises;
 var init_logger = (0, import_chunk_ABYVSU2C.__esm)({
   "src/logger.ts"() {
     "use strict";
@@ -5477,6 +5493,8 @@ var init_logger = (0, import_chunk_ABYVSU2C.__esm)({
     loggerLevelOffset = 0;
     theLogger = console.log;
     banner = null;
+    logPromise = Promise.resolve();
+    livePromises = 0;
   }
 });
 function globa(pattern, options) {
@@ -5673,7 +5691,7 @@ function popcount(x) {
   x += x >> 16;
   return x & 127;
 }
-var import_fast_glob, import_priorityqueuejs, GenericQueue;
+var import_fast_glob, import_priorityqueuejs, GenericQueue, AwaitedError;
 var init_util = (0, import_chunk_ABYVSU2C.__esm)({
   "src/util.ts"() {
     import_fast_glob = (0, import_chunk_ABYVSU2C.__toESM)(require_out4());
@@ -5700,6 +5718,15 @@ var init_util = (0, import_chunk_ABYVSU2C.__esm)({
         return this.queue.isEmpty();
       }
     };
+    AwaitedError = class extends Error {
+      constructor(messagePromise) {
+        super();
+        this.messagePromise = messagePromise;
+      }
+      resolve() {
+        return this.messagePromise.then((message) => this.message = message);
+      }
+    };
   }
 });
 /*! Bundled license information:
@@ -5752,6 +5779,7 @@ run-parallel/index.js:
 */
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AwaitedError,
   GenericQueue,
   bumpLogging,
   copyRecursiveAsNeeded,
@@ -5764,6 +5792,7 @@ run-parallel/index.js:
   init_util,
   last_modified,
   log,
+  logPromise,
   logger,
   map,
   popcount,

package/build/optimizer.cjs

@@ -18,29 +18,28 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var optimizer_exports = {};
 __export(optimizer_exports, {
-  StateNodeAttributes: () => import_chunk_FD2NCZK4.StateNodeAttributes,
-  buildOptimizedProject: () => import_chunk_FD2NCZK4.buildOptimizedProject,
-  copyRecursiveAsNeeded: () => import_chunk_PVBIKZYZ.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_FD2NCZK4.defaultConfig,
-  display: () => import_chunk_FD2NCZK4.display,
-  generateApiMirTests: () => import_chunk_FD2NCZK4.generateApiMirTests,
-  generateOneConfig: () => import_chunk_FD2NCZK4.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_FD2NCZK4.generateOptimizedProject,
-  getConfig: () => import_chunk_FD2NCZK4.getConfig,
-  getProjectAnalysis: () => import_chunk_FD2NCZK4.getProjectAnalysis,
-  get_jungle: () => import_chunk_FD2NCZK4.get_jungle,
-  isErrorWithLocation: () => import_chunk_FD2NCZK4.isErrorWithLocation,
-  launchSimulator: () => import_chunk_FD2NCZK4.launchSimulator,
-  manifestProducts: () => import_chunk_FD2NCZK4.manifestProducts,
-  mctree: () => import_chunk_FD2NCZK4.mctree,
-  simulateProgram: () => import_chunk_FD2NCZK4.simulateProgram
+  StateNodeAttributes: () => import_chunk_E67DP34P.StateNodeAttributes,
+  buildOptimizedProject: () => import_chunk_E67DP34P.buildOptimizedProject,
+  copyRecursiveAsNeeded: () => import_chunk_SG7ODKRM.copyRecursiveAsNeeded,
+  defaultConfig: () => import_chunk_E67DP34P.defaultConfig,
+  display: () => import_chunk_E67DP34P.display,
+  generateOneConfig: () => import_chunk_E67DP34P.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_E67DP34P.generateOptimizedProject,
+  getConfig: () => import_chunk_E67DP34P.getConfig,
+  getProjectAnalysis: () => import_chunk_E67DP34P.getProjectAnalysis,
+  get_jungle: () => import_chunk_E67DP34P.get_jungle,
+  isErrorWithLocation: () => import_chunk_E67DP34P.isErrorWithLocation,
+  launchSimulator: () => import_chunk_E67DP34P.launchSimulator,
+  manifestProducts: () => import_chunk_E67DP34P.manifestProducts,
+  mctree: () => import_chunk_E67DP34P.mctree,
+  simulateProgram: () => import_chunk_E67DP34P.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_FD2NCZK4 = require("./chunk-FD2NCZK4.cjs");
-var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
+var import_chunk_E67DP34P = require("./chunk-E67DP34P.cjs");
+var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_FD2NCZK4.init_optimizer)();
+(0, import_chunk_E67DP34P.init_optimizer)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StateNodeAttributes,
@@ -48,7 +47,6 @@ var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
   copyRecursiveAsNeeded,
   defaultConfig,
   display,
-  generateApiMirTests,
   generateOneConfig,
   generateOptimizedProject,
   getConfig,

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_FD2NCZK4.SectionKinds,
-  appSupport: () => import_chunk_FD2NCZK4.appSupport,
-  connectiq: () => import_chunk_FD2NCZK4.connectiq,
-  getDeviceInfo: () => import_chunk_FD2NCZK4.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_FD2NCZK4.getFunctionDocumentation,
-  getLanguages: () => import_chunk_FD2NCZK4.getLanguages,
-  getSdkPath: () => import_chunk_FD2NCZK4.getSdkPath,
-  isWin: () => import_chunk_FD2NCZK4.isWin,
-  optimizeProgram: () => import_chunk_FD2NCZK4.optimizeProgram,
-  readPrg: () => import_chunk_FD2NCZK4.readPrg,
-  readPrgWithOffsets: () => import_chunk_FD2NCZK4.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_FD2NCZK4.xml_util_exports
+  SectionKinds: () => import_chunk_E67DP34P.SectionKinds,
+  appSupport: () => import_chunk_E67DP34P.appSupport,
+  connectiq: () => import_chunk_E67DP34P.connectiq,
+  getDeviceInfo: () => import_chunk_E67DP34P.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_E67DP34P.getFunctionDocumentation,
+  getLanguages: () => import_chunk_E67DP34P.getLanguages,
+  getSdkPath: () => import_chunk_E67DP34P.getSdkPath,
+  isWin: () => import_chunk_E67DP34P.isWin,
+  optimizeProgram: () => import_chunk_E67DP34P.optimizeProgram,
+  readPrg: () => import_chunk_E67DP34P.readPrg,
+  readPrgWithOffsets: () => import_chunk_E67DP34P.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_E67DP34P.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_FD2NCZK4 = require("./chunk-FD2NCZK4.cjs");
-var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
+var import_chunk_E67DP34P = require("./chunk-E67DP34P.cjs");
+var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_FD2NCZK4.init_sdk_util)();
+(0, import_chunk_E67DP34P.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/api.d.ts

@@ -1,12 +1,12 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
 import { JungleResourceMap } from "./jungles";
-import { ClassStateNode, Diagnostic, DiagnosticType, EnumStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, LookupResult, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode, VariableStateNode } from "./optimizer-types";
+import { ClassStateNode, Diagnostic, DiagnosticType, EnumStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, LookupResult, ModuleStateNode, PreDiagnostic, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode, VariableStateNode } from "./optimizer-types";
 import { visit_resources } from "./resources";
 import { xmlUtil } from "./sdk-util";
 import { TypeMap } from "./type-flow/interp";
-export { visitorNode, visitReferences } from "./visitor";
-export { traverseAst, hasProperty, visit_resources };
+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 getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): Promise<ProgramStateNode>;
@@ -21,13 +21,14 @@ 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 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 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 | FunctionStateNode | ClassStateNode | ModuleStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | EnumStateNode)[];
-export declare function formatAstLongLines(node: mctree.Node): string;
+export declare function formatScopedName(node: mctree.ScopedName | mctree.ThisExpression): string;
+export declare function formatAstLongLines(node: mctree.Node): Promise<string>;
 export declare function createDocumentationMap(functionDocumentation: {
     name: string;
     parent: string;
@@ -46,6 +47,6 @@ export declare function getApiFunctionInfo(state: ProgramState, func: FunctionSt
 export declare function markInvokeClassMethod(state: ProgramStateAnalysis, func: FunctionStateNode): void;
 export declare function isLocal(v: VariableStateNode): boolean;
 export declare function isClassVariable(v: VariableStateNode): boolean;
-export declare function diagnostic(state: ProgramState, node: mctree.Node, message: string | null, type?: DiagnosticType, extra?: Diagnostic["extra"]): void;
-export declare function diagnosticHelper(diagnostics: Record<string, Diagnostic[]>, node: mctree.Node, message: string | null, type: DiagnosticType | undefined, extra: Diagnostic["extra"] | undefined, uniqueLocs: boolean): void;
+export declare function diagnostic(state: ProgramState, node: mctree.Node, message: string | Promise<string> | null, type?: DiagnosticType, extra?: Diagnostic["extra"]): void;
+export declare function diagnosticHelper(diagnostics: Record<string, PreDiagnostic[]>, node: mctree.Node, message: string | Promise<string> | null, type: DiagnosticType | undefined, extra: Diagnostic["extra"] | undefined): void;
 export declare function getSuperClasses(klass: ClassStateNode): Set<StateNode> | null;

package/build/src/data-flow.d.ts

@@ -95,7 +95,7 @@ export type Event = RefEvent | KillEvent | DefEvent | ModEvent | FlowEvent | Exn
 export interface DataFlowBlock extends Block<Event> {
     order?: number;
 }
-export declare function declFullName(decl: EventDecl): string;
+export declare function declFullName(decl: EventDecl): Promise<string>;
 export declare function declName(decl: EventDecl): string | undefined;
 export declare function unhandledType(node: never): never;
 export declare function buildDataFlowGraph(state: ProgramStateAnalysis, func: FunctionStateNode, wantsLiteral: (literal: mctree.Literal) => boolean, trackInsertionPoints: boolean, wantsAllRefs: boolean): {

package/build/src/logger.d.ts

@@ -2,5 +2,6 @@ export declare function logger(module: string, level: number, message: unknown):
 export declare function wouldLog(module: string, level: number): boolean;
 export declare function bumpLogging(module: string | null, amount: number): void;
 export declare function setBanner(b: (() => string) | null): void;
-export declare function log(message: unknown): void;
+export declare let logPromise: Promise<unknown>;
+export declare function log(...messages: unknown[]): void;
 export declare function setLogger(log: (message: string) => void): void;

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

@@ -1,6 +1,6 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { JungleResourceMap } from "./jungles";
-import { BuildConfig, FilesToOptimizeMap, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
+import { BuildConfig, Diagnostic, FilesToOptimizeMap, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 import { xmlUtil } from "./sdk-util";
 export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
 export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
@@ -8,6 +8,6 @@ export declare function analyze(fnMap: FilesToOptimizeMap, resourcesMap: Record<
 export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): 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, import("./optimizer-types").Diagnostic[]> | undefined;
+    diagnostics: Record<string, Diagnostic[]> | undefined;
     sdkVersion: number | undefined;
 }>;

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

@@ -161,6 +161,9 @@ export interface Diagnostic extends DiagnosticBase {
         message: string;
     };
 }
+export type PreDiagnostic = Omit<Diagnostic, "message"> & {
+    message: string | Promise<string> | null;
+};
 type ProgramStateStackElem = {
     sn: StateNode;
     usings?: Record<string, ImportUsing>;
@@ -222,7 +225,7 @@ export type ProgramState = {
     constants?: {
         [key: string]: mctree.Literal;
     };
-    diagnostics?: Record<string, Diagnostic[]>;
+    diagnostics?: Record<string, PreDiagnostic[]>;
     inlineDiagnostics?: Record<string, Diagnostic[]>;
     enumMap?: Map<EnumStringMember, EnumStateNode>;
 };

package/build/src/optimizer.d.ts

@@ -1,5 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { get_jungle, JungleBuildDependencies, JungleError, JungleQualifier, JungleResourceMap, ResolvedJungle, Target } from "./jungles";
+import { JungleBuildDependencies, JungleError, JungleQualifier, JungleResourceMap, ResolvedJungle, Target, get_jungle } from "./jungles";
 import { launchSimulator, simulateProgram } from "./launch";
 import { manifestProducts } from "./manifest";
 import { BuildConfig, FilesToOptimizeMap, ProgramState, ProgramStateAnalysis } from "./optimizer-types";
@@ -7,8 +7,8 @@ import { xmlUtil } from "./sdk-util";
 import { TypeMap } from "./type-flow/interp";
 import { copyRecursiveAsNeeded } from "./util";
 export * from "./optimizer-types";
-export { display, ExactOrUnion } from "./type-flow/types";
-export { copyRecursiveAsNeeded, get_jungle, JungleBuildDependencies, JungleError, JungleResourceMap, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, TypeMap, };
+export { ExactOrUnion, display } from "./type-flow/types";
+export { JungleBuildDependencies, JungleError, JungleResourceMap, ResolvedJungle, TypeMap, copyRecursiveAsNeeded, get_jungle, launchSimulator, manifestProducts, mctree, simulateProgram, };
 export declare const defaultConfig: {
     outputPath: string;
     workspace: string;
@@ -50,7 +50,7 @@ export declare function buildOptimizedProject(product: string | null, options: B
     program: string;
     product: string | null;
     hasTests: boolean;
-    diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
+    diagnostics: Record<string, import("./optimizer-types").PreDiagnostic[]> | undefined;
 }>;
 export declare function generateOptimizedProject(options: BuildConfig): Promise<{
     jungleFiles: string | undefined;
@@ -63,7 +63,7 @@ export declare function generateOptimizedProject(options: BuildConfig): Promise<
     xml: xmlUtil.Document;
     program: string;
     hasTests: boolean;
-    diagnostics: Record<string, import("./optimizer-types").Diagnostic[]>;
+    diagnostics: Record<string, import("./optimizer-types").PreDiagnostic[]>;
 }>;
 export type PreAnalysis = {
     fnMap: FilesToOptimizeMap;
@@ -92,9 +92,3 @@ export declare function generateOneConfig(buildConfig: JungleQualifier, manifest
     sdkVersion: number | undefined;
 }>;
 export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, manifestXML: xmlUtil.Document, options: BuildConfig): Promise<Analysis | PreAnalysis>;
-/**
- *
- * @param {BuildConfig} options
- * @returns
- */
-export declare function generateApiMirTests(options: BuildConfig): Promise<void>;

package/build/src/pragma-checker.d.ts

@@ -1,3 +1,3 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ProgramState, ProgramStateOptimizer } from "./optimizer-types";
-export declare function pragmaChecker(state: ProgramStateOptimizer, ast: mctree.Program, diagnostics: NonNullable<ProgramState["diagnostics"]>[string] | null | undefined): void;
+import { Diagnostic, ProgramStateOptimizer } from "./optimizer-types";
+export declare function pragmaChecker(state: ProgramStateOptimizer, ast: mctree.Program, diagnostics: Diagnostic[] | null | undefined): Promise<void>;

package/build/src/pre.d.ts

@@ -1,2 +1,2 @@
 import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
-export declare function sizeBasedPRE(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function sizeBasedPRE(state: ProgramStateAnalysis, func: FunctionStateNode): Promise<void>;

package/build/src/type-flow/dead-store.d.ts

@@ -1,6 +1,6 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { NodeEquivMap } from "../type-flow";
 import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { NodeEquivMap } from "../type-flow";
 import { TypeFlowBlock, TypeStateKey } from "./type-flow-util";
 export type CopyPropStores = Map<mctree.Node, {
     ref: mctree.Node;

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

@@ -1,4 +1,11 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ExactOrUnion } from "./types";
-export declare function evaluateBinaryTypes(op: mctree.BinaryOperator | "instanceof", left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;
-export declare function evaluateLogicalTypes(op: mctree.LogicalOperator, left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;
+import { ExactOrUnion, TypeTag } from "./types";
+export type OpMatch = {
+    mismatch?: Map<TypeTag, TypeTag>;
+};
+export declare function evaluateBinaryTypes(op: mctree.BinaryOperator | "instanceof", left: ExactOrUnion, right: ExactOrUnion): {
+    type: ExactOrUnion;
+} & OpMatch;
+export declare function evaluateLogicalTypes(op: mctree.LogicalOperator, left: ExactOrUnion, right: ExactOrUnion): {
+    type: ExactOrUnion;
+} & OpMatch;

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

@@ -1,5 +1,6 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { DiagnosticType, FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { OpMatch } from "./interp-binary";
 import { ExactOrUnion, ObjectType } from "./types";
 export type TypeMap = Map<mctree.Node, ExactOrUnion>;
 export type InterpStackElem = {
@@ -24,7 +25,9 @@ export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.E
 export declare function preEvaluate(istate: InterpState, node: mctree.Node): null | (keyof mctree.NodeAll)[];
 export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
 export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
-export declare function evaluateUnaryTypes(op: mctree.UnaryOperator, argument: ExactOrUnion): ExactOrUnion;
+export declare function evaluateUnaryTypes(op: mctree.UnaryOperator, argument: ExactOrUnion): {
+    type: ExactOrUnion;
+} & OpMatch;
 export declare function deEnumerate(t: ExactOrUnion): ExactOrUnion;
 export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
 export declare function roundToFloat(value: number): number;

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

@@ -1,5 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { DataFlowBlock as TypeFlowBlock, Event, EventDecl } from "../data-flow";
+import { Event, EventDecl, DataFlowBlock as TypeFlowBlock } from "../data-flow";
 import { ProgramStateAnalysis, StateNode, VariableStateNode } from "../optimizer-types";
 import { InterpState } from "./interp";
 import { ExactOrUnion } from "./types";
@@ -14,7 +14,7 @@ export type TypeStateKey = Exclude<EventDecl, {
 export declare function tsKey(key: TypeStateKey): string;
 export declare function sourceLocation(loc: mctree.SourceLocation | null | undefined): string;
 export declare function printBlockHeader(block: TypeFlowBlock): void;
-export declare function describeEvent(event: Event): string;
+export declare function describeEvent(event: Event): Promise<string>;
 export declare function printBlockEvents(block: TypeFlowBlock, extra?: (event: Event) => string): void;
 export declare function printBlockTrailer(block: TypeFlowBlock): void;
 export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): readonly [null, null] | [StateNode[], StateNode[]];

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

@@ -41,6 +41,9 @@ interface AbstractValue {
     value?: unknown;
 }
 export type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | MethodType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType | TypedefType;
+export type ObjectLiteralType = Map<string, ExactOrUnion> & {
+    value?: undefined;
+};
 type ExactPairHelper<T> = T extends ExactTypes ? {
     type: T["type"];
     avalue: T["value"];
@@ -106,7 +109,7 @@ export interface DictionaryType extends AbstractValue {
     value?: {
         key: ExactOrUnion;
         value: ExactOrUnion;
-    } | undefined;
+    } | ObjectLiteralType | undefined;
 }
 export interface MethodType extends AbstractValue {
     type: TypeTag.Method;
@@ -184,8 +187,14 @@ export declare function isSingleton(v: AbstractValue): v is SingletonType;
 export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
 export declare function hasNoData(v: AbstractValue, t: TypeTag): boolean;
 export declare function cloneType<T extends ExactOrUnion>(t: T): T;
+export declare function relaxType(type: ExactOrUnion): {
+    type: number;
+};
 export declare function typeFromTypeStateNode(state: ProgramStateAnalysis, sn: StateNodeDecl, classVsObj?: boolean): ExactOrUnion;
 export declare function typeFromTypeStateNodes(state: ProgramStateAnalysis, sns: StateNodeDecl[], classVsObj?: boolean): ExactOrUnion;
+export declare function objectLiteralKeyFromExpr(key: mctree.Expression): string | null;
+export declare function objectLiteralKeyFromType(key: ExactOrUnion): string | null;
+export declare function typeFromObjectLiteralKey(key: string): ValueTypes;
 export declare function typeFromSingleTypeSpec(state: ProgramStateAnalysis, type: mctree.TypeSpecPart | mctree.ObjectExpression, stack?: ProgramStateStack | undefined): ExactOrUnion;
 export declare function typeFromTypespec(state: ProgramStateAnalysis, ts: mctree.TypeSpecList, stack?: ProgramStateStack | undefined): ExactOrUnion;
 export declare function typeFromLiteral(literal: mctree.Literal): ExactTypes;

package/build/src/util.d.ts

@@ -1,5 +1,5 @@
 import glob from "fast-glob";
-export { logger, log, wouldLog, setBanner, bumpLogging } from "./logger";
+export { bumpLogging, log, logPromise, logger, setBanner, wouldLog, } from "./logger";
 export declare function globa(pattern: string, options?: glob.Options & {
     mark?: boolean;
 }): Promise<Array<string>>;
@@ -31,3 +31,8 @@ export declare class GenericQueue<Block> {
     dequeue(): Block;
     empty(): boolean;
 }
+export declare class AwaitedError extends Error {
+    private messagePromise;
+    constructor(messagePromise: Promise<string>);
+    resolve(): Promise<string>;
+}

package/build/src/worker-task.d.ts

@@ -52,7 +52,7 @@ export declare const workerTaskHandlers: {
         program: string;
         product: string | null;
         hasTests: boolean;
-        diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
+        diagnostics: Record<string, import("./optimizer-types").PreDiagnostic[]> | undefined;
     }>;
     readonly generateOptimizedProject: (data: GenerateOptimizedProject["data"]) => Promise<{
         jungleFiles: string | undefined;
@@ -65,11 +65,11 @@ export declare const workerTaskHandlers: {
         xml: xmlUtil.Document;
         program: string;
         hasTests: boolean;
-        diagnostics: Record<string, import("./optimizer-types").Diagnostic[]>;
+        diagnostics: Record<string, import("./optimizer-types").PreDiagnostic[]>;
     }>;
     readonly generateOneConfig: (data: GenerateOneConfig["data"]) => Promise<{
         hasTests: boolean;
-        diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
+        diagnostics: Record<string, import("./optimizer-types").PreDiagnostic[]> | undefined;
         sdkVersion: number | undefined;
     }>;
     readonly optimizePrgAndDebug: (data: OptimizePrgAndDebug["data"]) => Promise<{

package/build/util.cjs

@@ -18,35 +18,38 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var util_exports = {};
 __export(util_exports, {
-  GenericQueue: () => import_chunk_PVBIKZYZ.GenericQueue,
-  bumpLogging: () => import_chunk_PVBIKZYZ.bumpLogging,
-  copyRecursiveAsNeeded: () => import_chunk_PVBIKZYZ.copyRecursiveAsNeeded,
-  every: () => import_chunk_PVBIKZYZ.every,
-  first_modified: () => import_chunk_PVBIKZYZ.first_modified,
-  forEach: () => import_chunk_PVBIKZYZ.forEach,
-  globSome: () => import_chunk_PVBIKZYZ.globSome,
-  globa: () => import_chunk_PVBIKZYZ.globa,
-  last_modified: () => import_chunk_PVBIKZYZ.last_modified,
-  log: () => import_chunk_PVBIKZYZ.log,
-  logger: () => import_chunk_PVBIKZYZ.logger,
-  map: () => import_chunk_PVBIKZYZ.map,
-  popcount: () => import_chunk_PVBIKZYZ.popcount,
-  promiseAll: () => import_chunk_PVBIKZYZ.promiseAll,
-  pushUnique: () => import_chunk_PVBIKZYZ.pushUnique,
-  readByLine: () => import_chunk_PVBIKZYZ.readByLine,
-  reduce: () => import_chunk_PVBIKZYZ.reduce,
-  sameArrays: () => import_chunk_PVBIKZYZ.sameArrays,
-  setBanner: () => import_chunk_PVBIKZYZ.setBanner,
-  some: () => import_chunk_PVBIKZYZ.some,
-  spawnByLine: () => import_chunk_PVBIKZYZ.spawnByLine,
-  wouldLog: () => import_chunk_PVBIKZYZ.wouldLog
+  AwaitedError: () => import_chunk_SG7ODKRM.AwaitedError,
+  GenericQueue: () => import_chunk_SG7ODKRM.GenericQueue,
+  bumpLogging: () => import_chunk_SG7ODKRM.bumpLogging,
+  copyRecursiveAsNeeded: () => import_chunk_SG7ODKRM.copyRecursiveAsNeeded,
+  every: () => import_chunk_SG7ODKRM.every,
+  first_modified: () => import_chunk_SG7ODKRM.first_modified,
+  forEach: () => import_chunk_SG7ODKRM.forEach,
+  globSome: () => import_chunk_SG7ODKRM.globSome,
+  globa: () => import_chunk_SG7ODKRM.globa,
+  last_modified: () => import_chunk_SG7ODKRM.last_modified,
+  log: () => import_chunk_SG7ODKRM.log,
+  logPromise: () => import_chunk_SG7ODKRM.logPromise,
+  logger: () => import_chunk_SG7ODKRM.logger,
+  map: () => import_chunk_SG7ODKRM.map,
+  popcount: () => import_chunk_SG7ODKRM.popcount,
+  promiseAll: () => import_chunk_SG7ODKRM.promiseAll,
+  pushUnique: () => import_chunk_SG7ODKRM.pushUnique,
+  readByLine: () => import_chunk_SG7ODKRM.readByLine,
+  reduce: () => import_chunk_SG7ODKRM.reduce,
+  sameArrays: () => import_chunk_SG7ODKRM.sameArrays,
+  setBanner: () => import_chunk_SG7ODKRM.setBanner,
+  some: () => import_chunk_SG7ODKRM.some,
+  spawnByLine: () => import_chunk_SG7ODKRM.spawnByLine,
+  wouldLog: () => import_chunk_SG7ODKRM.wouldLog
 });
 module.exports = __toCommonJS(util_exports);
-var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
+var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_PVBIKZYZ.init_util)();
+(0, import_chunk_SG7ODKRM.init_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AwaitedError,
   GenericQueue,
   bumpLogging,
   copyRecursiveAsNeeded,
@@ -57,6 +60,7 @@ var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
   globa,
   last_modified,
   log,
+  logPromise,
   logger,
   map,
   popcount,

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_FD2NCZK4 = require("./chunk-FD2NCZK4.cjs");
-var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
+var import_chunk_E67DP34P = require("./chunk-E67DP34P.cjs");
+var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.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_FD2NCZK4.init_worker_task)();
+    (0, import_chunk_E67DP34P.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_FD2NCZK4.performTask)(task));
+        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_E67DP34P.performTask)(task));
       });
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "commonjs",
-  "version": "1.1.36",
+  "version": "1.1.37",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -49,7 +49,8 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.52"
+    "@markw65/peggy-optimizer": "^1.0.1",
+    "@markw65/prettier-plugin-monkeyc": "^1.0.53"
   },
   "devDependencies": {
     "@types/chai": "^4.3.4",