@markw65/monkeyc-optimizer 1.0.44 → 1.1.0

package/build/sdk-util.cjs

@@ -237,8 +237,6 @@ function mayThrow(node) {
     switch (node.type) {
         case "BinaryExpression":
         case "CallExpression":
-        case "ConditionalExpression":
-        case "LogicalExpression":
         case "NewExpression":
         case "ThrowStatement":
         case "UnaryExpression":
@@ -325,6 +323,86 @@ function getNodeValue(node) {
     }
     throw new Error(`Literal has unknown type '${type}'`);
 }
+function wrap(node, loc) {
+    if (loc) {
+        node.loc = loc;
+        node.start = loc.start.offset;
+        node.end = loc.end.offset;
+    }
+    return node;
+}
+function locRange(start, end) {
+    return {
+        source: start.source || end.source,
+        start: start.start,
+        end: end.end,
+    };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+    return {
+        source: loc.source,
+        start: {
+            offset: loc.start.offset + start,
+            line: loc.start.line,
+            column: loc.start.column + start,
+        },
+        end: {
+            offset: loc.end.offset + end,
+            line: loc.end.line,
+            column: loc.end.column + end,
+        },
+    };
+}
+function makeIdentifier(name, loc) {
+    return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+    return wrap({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+    }, object.loc && locRange(object.loc, property.loc));
+}
+function makeScopedName(dotted, l) {
+    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+    const result = dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
+        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
+        if (!cur) {
+            cur = id;
+        }
+        else {
+            cur = makeMemberExpression(cur, id);
+        }
+        offset += next.length + 1;
+        return { cur, offset };
+    }, { cur: null, offset: 0 }).cur;
+    if (!result)
+        throw new Error("Failed to make a ScopedName");
+    return result;
+}
+function getLiteralNode(node) {
+    if (node == null)
+        return null;
+    if (node.type == "Literal")
+        return node;
+    if (node.type == "BinaryExpression" && node.operator == "as") {
+        return getLiteralNode(node.left) && node;
+    }
+    if (node.type == "UnaryExpression") {
+        if (node.argument.type != "Literal")
+            return null;
+        switch (node.operator) {
+            case "-": {
+                const [arg, type] = getNodeValue(node.argument);
+                if (type === "Number" || type === "Long") {
+                    return { ...arg, value: -arg.value, raw: `-${arg.raw}` };
+                }
+            }
+        }
+    }
+    return null;
+}
 
 ;// CONCATENATED MODULE: ./src/xml-util.ts
 

package/build/src/api.d.ts

@@ -1,7 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
 import { JungleResourceMap } from "./jungles";
-import { FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl } from "./optimizer-types";
+import { ClassStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, VariableStateNode } from "./optimizer-types";
 import { visit_resources } from "./resources";
 import { xmlUtil } from "./sdk-util";
 export { visitorNode, visitReferences } from "./visitor";
@@ -22,5 +22,8 @@ export declare function findUsingForNode(state: ProgramStateLive, stack: Program
         results: StateNodeDecl[];
     };
 }[] | null;
-export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo;
-export declare function markInvokeClassMethod(func: FunctionStateNode): void;
+export declare function getApiFunctionInfo(state: ProgramState, func: FunctionStateNode): FunctionInfo | false;
+export declare function markInvokeClassMethod(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function isLocal(v: VariableStateNode): boolean;
+export declare function diagnostic(state: ProgramState, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
+export declare function getSuperClasses(klass: ClassStateNode): Set<ClassStateNode> | null;

package/build/src/ast.d.ts

@@ -1,4 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import type { xmlUtil } from "./sdk-util";
 export declare function traverseAst(node: mctree.Node, pre?: null | ((node: mctree.Node) => void | null | false | (keyof mctree.NodeAll)[]), post?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[]): false | void | null | mctree.Node | mctree.Node[];
 export declare function isStatement(node: mctree.Node): node is mctree.Statement;
 export declare function isExpression(node: mctree.Node): node is mctree.Expression;
@@ -29,4 +30,30 @@ interface NullLiteral extends mctree.Literal {
 declare type LiteralValues = [NumberLiteral, "Number" | "Float" | "Double"] | [LongLiteral, "Long"] | [StringLiteral, "String"] | [CharLiteral, "Char"] | [BooleanLiteral, "Boolean"] | [NullLiteral, "Null"];
 export declare function getNodeValue(node: mctree.Literal): LiteralValues;
 export declare function getNodeValue(node: mctree.Node): LiteralValues | [null, null];
+export declare function wrap<T extends mctree.Node>(node: T, loc?: mctree.SourceLocation | null): T;
+export declare function locRange(start: mctree.SourceLocation, end: mctree.SourceLocation): {
+    source: string | null | undefined;
+    start: mctree.Position;
+    end: mctree.Position;
+};
+export declare function adjustLoc(loc: xmlUtil.SourceLocation, start?: number, end?: number): {
+    readonly source: string | null | undefined;
+    readonly start: {
+        readonly offset: number;
+        readonly line: number;
+        readonly column: number;
+    };
+    readonly end: {
+        readonly offset: number;
+        readonly line: number;
+        readonly column: number;
+    };
+};
+export declare function makeIdentifier(name: string, loc?: mctree.SourceLocation | null | undefined): {
+    type: "Identifier";
+    name: string;
+};
+export declare function makeMemberExpression(object: mctree.ScopedName, property: mctree.Identifier): mctree.DottedName;
+export declare function makeScopedName(dotted: string, l?: mctree.SourceLocation): mctree.ScopedName;
+export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
 export {};

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

@@ -13,7 +13,7 @@ export declare type Block<T extends EventConstraint<T>> = {
     exsucc?: Block<T>;
     events?: T[];
 };
-export declare function buildReducedGraph<T extends EventConstraint<T>>(state: ProgramStateAnalysis, func: FunctionStateNode, notice: (node: mctree.Node, stmt: mctree.Node, mayThrow: boolean) => T | null): Block<T>;
+export declare function buildReducedGraph<T extends EventConstraint<T>>(state: ProgramStateAnalysis, func: FunctionStateNode, notice: (node: mctree.Node, stmt: mctree.Node, mayThrow: boolean | 1) => T | null): Block<T>;
 export declare function postOrderTraverse<T extends EventConstraint<T>>(head: Block<T>, visitor: (block: Block<T>) => void): void;
 export declare function preOrderTraverse<T extends EventConstraint<T>>(head: Block<T>, visitor: (block: Block<T>) => void): void;
 export declare function getPostOrder<T extends EventConstraint<T>>(head: Block<T>): Block<T>[];

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

@@ -0,0 +1,45 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { BaseEvent, Block } from "./control-flow";
+import { FunctionStateNode, ProgramStateAnalysis, StateNodeDecl } from "./optimizer-types";
+export declare type RefNode = mctree.Identifier | mctree.MemberExpression | mctree.Literal;
+export declare type EventDecl = StateNodeDecl | StateNodeDecl[] | mctree.Literal;
+export interface RefEvent extends BaseEvent {
+    type: "ref";
+    node: RefNode;
+    decl: EventDecl;
+}
+export interface DefEvent extends BaseEvent {
+    type: "def";
+    node: mctree.AssignmentExpression | mctree.UpdateExpression | mctree.VariableDeclarator;
+    decl: EventDecl;
+}
+export interface ModEvent extends BaseEvent {
+    type: "mod";
+    node: mctree.Node;
+    decl?: EventDecl | undefined | null;
+    before?: boolean;
+    id?: RefNode;
+    callees?: FunctionStateNode[] | null;
+}
+export interface ExnEvent extends BaseEvent {
+    type: "exn";
+    node: mctree.Node;
+}
+export declare type Event = RefEvent | DefEvent | ModEvent | ExnEvent;
+export interface DataFlowBlock extends Block<Event> {
+    order?: number;
+}
+export declare function declFullName(decl: EventDecl): string | undefined;
+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): {
+    identifiers: Set<string>;
+    graph: Block<RefEvent | DefEvent | ModEvent | ExnEvent>;
+};
+export declare class DataflowQueue {
+    private enqueued;
+    private queue;
+    enqueue(block: DataFlowBlock): void;
+    dequeue(): DataFlowBlock;
+    empty(): boolean;
+}

package/build/src/function-info.d.ts

@@ -1,3 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { VariableStateNode, FunctionStateNode, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 export declare function cloneSet<T>(ae: Set<T>): Set<T>;
 export declare function mergeSet<T>(a: Set<T>, b: Set<T>): void;
@@ -10,3 +11,4 @@ export declare function recordCalledFuncs(func: FunctionStateNode, callees: Func
 export declare function functionMayModify(state: ProgramStateAnalysis, func: FunctionStateNode, decl: VariableStateNode): boolean;
 export declare function findCallees(lookupDefs: LookupDefinition[]): FunctionStateNode[] | null;
 export declare function findCalleesForNew(lookupDefs: LookupDefinition[]): FunctionStateNode[];
+export declare function findCalleesByNode(state: ProgramStateAnalysis, callee: mctree.Expression): FunctionStateNode[] | null;

package/build/src/inliner.d.ts

@@ -1,11 +1,10 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { FunctionStateNode, ProgramState, ProgramStateAnalysis } from "./optimizer-types";
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
 export declare function inlinableSubExpression(expr: mctree.Expression): mctree.SimpleCallExpression | null;
 export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): boolean;
 declare type InlineBody = mctree.BlockStatement | mctree.ExpressionStatement["expression"];
 export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];
 export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | null;
-export declare function diagnostic(state: ProgramState, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
 export declare type InlineContext = mctree.ReturnStatement | mctree.IfStatement | mctree.AssignmentExpression | mctree.ExpressionStatement | mctree.VariableDeclarator;
 export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): InlineBody | null;
 export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;

package/build/src/jungles.d.ts

@@ -1,6 +1,6 @@
 import { ManifestXML } from "./manifest";
 import { BuildConfig } from "./optimizer-types.js";
-import { xmlUtil } from "./sdk-util";
+import { DeviceInfo, xmlUtil } from "./sdk-util";
 export declare type JungleBuildDependencies = Record<string, xmlUtil.Document | true>;
 export declare type JungleError = Error & {
     buildDependencies?: JungleBuildDependencies;
@@ -49,6 +49,7 @@ declare type JungleInfoBase = {
     annotations?: string[];
     resources: JungleResourceMap;
     buildDependencies: JungleBuildDependencies;
+    devices: DeviceInfo;
 };
 export declare type JungleResourceMap = Record<string, xmlUtil.Document>;
 export declare type ResolvedJungle = JungleInfoBase & {

package/build/src/manifest.d.ts

@@ -7,4 +7,5 @@ export declare function manifestBarrels(manifest: ManifestXML): string[];
 export declare function manifestDropBarrels(manifest: ManifestXML): void;
 export declare function manifestBarrelName(manifestName: string, manifest: ManifestXML): string;
 export declare function manifestAnnotations(manifest: ManifestXML): string[] | undefined;
+export declare function manifestLanguages(manifest: ManifestXML): string[] | undefined;
 export declare function checkManifest(manifest: ManifestXML, products: string[]): Promise<boolean>;

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

@@ -4,10 +4,9 @@ import { BuildConfig, FilesToOptimizeMap, LookupDefinition, ProgramStateAnalysis
 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, config: BuildConfig): Promise<ProgramStateAnalysis>;
+export declare function analyze(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document | undefined, config: BuildConfig): Promise<ProgramStateAnalysis>;
 export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): void;
 export declare function getLiteralFromDecls(lookupDefns: LookupDefinition[]): mctree.Literal | mctree.AsExpression | null;
-export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
 export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document, config: BuildConfig): Promise<Record<string, {
     type: import("./optimizer-types").DiagnosticType;
     loc: {

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

@@ -1,5 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { EnumStringMember } from "@markw65/prettier-plugin-monkeyc/build/estree-types";
 import { xmlUtil } from "./sdk-util";
+import { ExactOrUnion } from "./type-flow/types";
 export declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
 export declare type LookupRules = "COMPILER1" | "COMPILER2" | "DEFAULT";
 export declare type EnforceStatic = "YES" | "NO";
@@ -33,8 +35,11 @@ export declare type BuildConfig = {
     prettier?: Record<string, unknown>;
     extensionVersion?: string;
     useLocalOptimizer?: boolean;
+    propagateTypes?: boolean;
+    trustDeclaredTypes?: boolean;
+    checkTypes?: DiagnosticType | "OFF";
 };
-export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
+export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier;
 export declare type StateNodeDecls = {
     [key: string]: StateNodeDecl[];
 };
@@ -80,6 +85,7 @@ export interface ClassStateNode extends BaseStateNode {
     fullName: string;
     superClass?: ClassStateNode[] | true;
     hasInvoke?: boolean;
+    superClasses?: Set<ClassStateNode>;
 }
 export declare type FunctionInfo = {
     modifiedDecls: Set<VariableStateNode>;
@@ -96,7 +102,7 @@ export interface FunctionStateNode extends BaseStateNode {
     fullName: string;
     stack?: ProgramStateStack;
     decls?: undefined;
-    info?: FunctionInfo;
+    info?: FunctionInfo | false;
     next_info?: FunctionInfo;
 }
 export interface BlockStateNode extends BaseStateNode {
@@ -111,6 +117,9 @@ export interface TypedefStateNode extends BaseStateNode {
     node: mctree.TypedefDeclaration;
     name: string;
     fullName: string;
+    isExpanding?: true;
+    isRecursive?: true;
+    resolvedType?: ExactOrUnion;
 }
 export interface VariableStateNode extends BaseStateNode {
     type: "VariableDeclarator";
@@ -120,7 +129,14 @@ export interface VariableStateNode extends BaseStateNode {
     stack: ProgramStateStack;
     used?: true;
 }
-export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode;
+export interface EnumStateNode extends BaseStateNode {
+    type: "EnumDeclaration";
+    node: mctree.EnumDeclaration;
+    name: string;
+    fullName: string;
+    stack: ProgramStateStack;
+}
+export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode | EnumStateNode;
 export declare type ProgramStateStack = StateNode[];
 export declare type LookupDefinition = {
     parent: StateNode | null;
@@ -130,6 +146,7 @@ export declare type LookupResult = [string, LookupDefinition[]] | [null, null] |
 export declare type ProgramState = {
     allFunctions?: Record<string, FunctionStateNode[]>;
     allClasses?: ClassStateNode[];
+    invokeInfo?: FunctionInfo;
     fnMap?: FilesToOptimizeMap;
     rezAst?: mctree.Program;
     manifestXML?: xmlUtil.Document;
@@ -180,12 +197,13 @@ export declare type ProgramState = {
         };
         message: string;
     }[]>;
+    enumMap?: Map<EnumStringMember, EnumStateNode>;
 };
-declare type Finalized<T, Keys extends keyof T> = T & {
+export declare type Finalized<T, Keys extends keyof T> = T & {
     [key in Keys]-?: NonNullable<T[key]>;
 };
 export declare type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
-export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap">;
+export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap" | "invokeInfo">;
 export declare type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
 export declare type ExcludeAnnotationsMap = {
     [key: string]: boolean;

package/build/src/pre.d.ts

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

package/build/src/projects.d.ts

@@ -13,9 +13,10 @@ export declare type RemoteProject = string | {
     sourcePath?: string;
     jungleContent?: string[];
     garminOptLevel?: number;
+    test?: boolean;
 };
 export declare const githubProjects: RemoteProject[];
-export declare function fetchGitProjects(projects: RemoteProject[]): Promise<(string | {
+export declare function fetchGitProjects(projects: RemoteProject[], testOnly: boolean): Promise<(string | {
     jungle: string;
     build: boolean | null;
     options: BuildConfig | null;

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

@@ -0,0 +1,3 @@
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+import { InterpState } from "./type-flow/interp";
+export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode): InterpState | undefined;

package/build/src/util.d.ts

@@ -5,9 +5,14 @@ export declare function globa(pattern: string, options?: glob.Options & {
 export declare function globSome(pattern: string, predicate: (path: string) => boolean, options?: glob.Options & {
     mark?: boolean;
 }): Promise<boolean>;
+export declare function forEach<T>(val: T | T[] | null | undefined, fn: (v: T) => void): void;
+export declare function map<T, U>(val: T | T[] | null | undefined, fn: (v: T) => U): U[];
+export declare function every<T>(val: T | T[] | null | undefined, fn: (v: T) => void): boolean | void;
+export declare function some<T>(val: T | T[] | null | undefined, fn: (v: T) => void): boolean | void;
+export declare function reduce<T, U>(val: T | T[] | null | undefined, fn: (p: U, v: T) => U, init: U): U;
 export declare function last_modified(inputs: string[]): Promise<number>;
 export declare function first_modified(inputs: string[]): Promise<number>;
-export declare function pushUnique<T, U extends T>(arr: T[], value: U): void;
+export declare function pushUnique<T, U extends T>(arr: T[], value: U): boolean;
 export declare function sameArrays<T>(a1: T[], a2: T[], check: (a: T, b: T) => boolean): boolean;
 export declare type LineHandler = (line: string) => void;
 export declare function spawnByLine(command: string, args: string[], lineHandlers: LineHandler | LineHandler[], options?: {

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

@@ -1,4 +1,4 @@
 import type { WorkerTask, WorkerTaskResult } from "./worker-task";
-export declare function startPool(): void;
+export declare function startPool(parallelism?: number): void;
 export declare function stopPool(): void;
 export declare function runTaskInPool<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;

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

@@ -1,29 +1,60 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { BuildConfig } from "./optimizer";
 interface BaseNode {
     type: string;
     data: unknown;
 }
-interface ParserData extends BaseNode {
+interface BuildOptimizedProject extends BaseNode {
+    type: "buildOptimizedProject";
     data: {
-        source: string;
-        options?: Record<string, unknown>;
+        product: string | null;
+        options: BuildConfig;
     };
 }
-interface JungleParserTask extends ParserData {
-    type: "parseJungle";
-}
-interface MonkeyCParserTask extends ParserData {
-    type: "parseMonkeyC";
-}
-interface XmlParserTask extends ParserData {
-    type: "parseXml";
+interface GenerateOptimizedProject extends BaseNode {
+    type: "generateOptimizedProject";
+    data: {
+        options: BuildConfig;
+    };
 }
-export declare type WorkerTask = JungleParserTask | MonkeyCParserTask | XmlParserTask;
+export declare type WorkerTask = BuildOptimizedProject | GenerateOptimizedProject;
 export declare const workerTaskHandlers: {
-    readonly parseJungle: (data: JungleParserTask["data"]) => Assignment[];
-    readonly parseMonkeyC: (data: MonkeyCParserTask["data"]) => mctree.Program;
-    readonly parseXml: (data: XmlParserTask["data"]) => ParserResult;
+    readonly buildOptimizedProject: (data: BuildOptimizedProject["data"]) => Promise<{
+        exe: string;
+        args: string[];
+        program: string;
+        product: string | null;
+        hasTests: boolean;
+        diagnostics: Record<string, {
+            type: import("./optimizer-types").DiagnosticType;
+            loc: {
+                start: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+                end: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+            };
+            message: string;
+        }[]> | undefined;
+    }>;
+    readonly generateOptimizedProject: (data: GenerateOptimizedProject["data"]) => Promise<{
+        jungleFiles: string | undefined;
+        xml: import("./xml-util").Document;
+        program: string;
+        hasTests: boolean;
+        diagnostics?: undefined;
+    } | {
+        jungleFiles: string;
+        xml: import("./xml-util").Document;
+        program: string;
+        hasTests: boolean;
+        diagnostics: Record<string, {
+            type: import("./optimizer-types").DiagnosticType;
+            loc: {
+                start: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+                end: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+            };
+            message: string;
+        }[]>;
+    }>;
 };
-export declare type WorkerTaskResult<T> = T extends WorkerTask ? ReturnType<typeof workerTaskHandlers[T["type"]]> : never;
-export declare function performTask<T extends WorkerTask>(task: T): WorkerTaskResult<T>;
+declare type RemovePromise<T> = T extends Promise<infer U> ? U : T;
+export declare type WorkerTaskResult<T> = T extends WorkerTask ? RemovePromise<ReturnType<typeof workerTaskHandlers[T["type"]]>> : never;
+export declare function performTask<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;
 export {};

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

@@ -0,0 +1 @@
+export {};

package/build/util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,first_modified,globSome,globa,last_modified,promiseAll,pushUnique,readByLine,sameArrays,spawnByLine});
+0 && (module.exports = {copyRecursiveAsNeeded,every,first_modified,forEach,globSome,globa,last_modified,map,promiseAll,pushUnique,readByLine,reduce,sameArrays,some,spawnByLine});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -7713,14 +7713,19 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   "copyRecursiveAsNeeded": () => (/* binding */ copyRecursiveAsNeeded),
+  "every": () => (/* binding */ every),
   "first_modified": () => (/* binding */ first_modified),
+  "forEach": () => (/* binding */ forEach),
   "globSome": () => (/* binding */ globSome),
   "globa": () => (/* binding */ globa),
   "last_modified": () => (/* binding */ last_modified),
+  "map": () => (/* binding */ map),
   "promiseAll": () => (/* binding */ promiseAll),
   "pushUnique": () => (/* binding */ pushUnique),
   "readByLine": () => (/* binding */ readByLine),
+  "reduce": () => (/* binding */ reduce),
   "sameArrays": () => (/* binding */ sameArrays),
+  "some": () => (/* binding */ some),
   "spawnByLine": () => (/* binding */ spawnByLine)
 });
 
@@ -7770,6 +7775,56 @@ function globSome(pattern, predicate, options) {
         });
     });
 }
+function forEach(val, fn) {
+    if (!val)
+        return;
+    if (Array.isArray(val)) {
+        val.forEach(fn);
+    }
+    else {
+        fn(val);
+    }
+}
+function map(val, fn) {
+    if (!val)
+        return [];
+    if (Array.isArray(val)) {
+        return val.map(fn);
+    }
+    else {
+        return [fn(val)];
+    }
+}
+function every(val, fn) {
+    if (!val)
+        return true;
+    if (Array.isArray(val)) {
+        return val.every(fn);
+    }
+    else {
+        return fn(val);
+    }
+}
+function some(val, fn) {
+    if (!val)
+        return false;
+    if (Array.isArray(val)) {
+        return val.some(fn);
+    }
+    else {
+        return fn(val);
+    }
+}
+function reduce(val, fn, init) {
+    if (!val)
+        return init;
+    if (Array.isArray(val)) {
+        return val.reduce(fn, init);
+    }
+    else {
+        return fn(init, val);
+    }
+}
 async function modified_times(inputs, missing) {
     return Promise.all(inputs.map(async (path) => {
         try {
@@ -7789,8 +7844,9 @@ async function first_modified(inputs) {
 }
 function pushUnique(arr, value) {
     if (arr.find((v) => v === value) != null)
-        return;
+        return false;
     arr.push(value);
+    return true;
 }
 function sameArrays(a1, a2, check) {
     return a1.length === a2.length && a1.every((e, i) => check(e, a2[i]));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.44",
+  "version": "1.1.0",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -21,8 +21,10 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-optimized && npm run test-unopt && npm run test-remote",
+    "test": "npm run test-mocha && npm run test-optimized && npm run test-unopt && npm run test-remote && npm run test-remote-tests",
+    "test-mocha": "npx mocha --timeout 999999 build/mocha.cjs",
     "test-remote": "node ./test/test.js --product=pick-one --github",
+    "test-remote-tests": "node ./test/test.js --product=pick-one --run-tests --github",
     "test-optimized": "node test/test.js --typeCheckLevel Strict --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "test-unopt": "node test/test.js --typeCheckLevel Strict --skipOptimization --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "test-garmin-opt": "node test/test.js --typeCheckLevel Strict --skipOptimization --garminOptLevel=2 --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
@@ -38,17 +40,21 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.40"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.41"
   },
   "devDependencies": {
+    "@types/chai": "^4.3.4",
     "@types/glob": "^8.0.0",
+    "@types/mocha": "^10.0.1",
     "@types/prettier": "^2.6.1",
     "@types/priorityqueuejs": "^1.0.1",
     "@typescript-eslint/eslint-plugin": "^5.28.0",
     "@typescript-eslint/parser": "^5.28.0",
+    "chai": "^4.3.7",
     "eslint": "^8.12.0",
     "extract-zip": "^2.0.1",
     "fast-glob": "^3.2.12",
+    "mocha": "^10.2.0",
     "peggy": "^2.0.1",
     "prettier": "^2.6.2",
     "prettier-plugin-pegjs": "https://github.com/markw65/prettier-plugin-pegjs/releases/download/v0.5.2/prettier-plugin-pegjs-0.5.2.tgz",