@markw65/monkeyc-optimizer 1.0.45 → 1.1.1

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":
@@ -383,6 +381,28 @@ function makeScopedName(dotted, l) {
         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, VariableStateNode } 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,6 +22,8 @@ export declare function findUsingForNode(state: ProgramStateLive, stack: Program
         results: StateNodeDecl[];
     };
 }[] | null;
-export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo | false;
-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

@@ -55,4 +55,5 @@ export declare function makeIdentifier(name: string, loc?: mctree.SourceLocation
 };
 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

@@ -31,7 +31,7 @@ export interface DataFlowBlock extends Block<Event> {
 }
 export declare function declFullName(decl: EventDecl): string | undefined;
 export declare function declName(decl: EventDecl): string | undefined;
-export declare function unhandledExpression(node: never): void;
+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>;

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/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,6 +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";
@@ -34,6 +35,9 @@ 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;
 export declare type StateNodeDecls = {
@@ -81,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>;
@@ -112,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";
@@ -138,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;
@@ -190,11 +199,11 @@ export declare type ProgramState = {
     }[]>;
     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/type-flow/could-be.d.ts

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function couldBe(a: ExactOrUnion, b: ExactOrUnion): boolean;

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

@@ -1,4 +1,4 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ExactOrUnion } from "./mc-types";
+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;

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

@@ -0,0 +1,4 @@
+import { ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion } from "./types";
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function evaluateCall(state: ProgramStateAnalysis, node: mctree.CallExpression, callee: ExactOrUnion, _args: ExactOrUnion[]): ExactOrUnion;

package/build/src/{interp.d.ts → type-flow/interp.d.ts}

@@ -1,6 +1,6 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ExactOrUnion } from "./type-flow/types";
-import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion } from "./types";
 export declare type TypeMap = Map<mctree.Node, ExactOrUnion>;
 export declare type InterpStackElem = {
     value: ExactOrUnion;
@@ -12,8 +12,8 @@ export declare type InterpState = {
     stack: InterpStackElem[];
     typeMap?: TypeMap;
     func?: FunctionStateNode;
-    pre?: (node: mctree.Node) => mctree.Node | null | void;
-    post?: (node: mctree.Node) => mctree.Node | null | void;
+    pre?: (node: mctree.Node) => mctree.Node | false | null | void;
+    post?: (node: mctree.Node) => mctree.Node | false | null | void;
 };
 export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
 export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;

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

@@ -0,0 +1,4 @@
+import { ExactOrUnion } from "./types";
+export declare function expandTypedef(t: ExactOrUnion): ExactOrUnion;
+export declare function intersection(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;
+export declare function restrictByEquality(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;

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

@@ -0,0 +1,6 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { InterpState } from "./interp";
+export declare function optimizeFunction(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function beforeEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;
+export declare function afterEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;

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

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function subtypeOf(a: ExactOrUnion, b: ExactOrUnion): boolean;

package/build/src/{mc-types.d.ts → type-flow/types.d.ts}

@@ -1,5 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl } from "./optimizer-types";
+import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl, TypedefStateNode } from "../optimizer-types";
 /**
  * TypeBit gives the position of the 1 bit in TypeTag
  */
@@ -20,7 +20,8 @@ export declare enum TypeBit {
     Class = 13,
     Object = 14,
     Enum = 15,
-    Symbol = 16
+    Symbol = 16,
+    Typedef = 17
 }
 export declare enum TypeTag {
     Never = 0,
@@ -43,16 +44,21 @@ export declare enum TypeTag {
     Object = 16384,
     Enum = 32768,
     Symbol = 65536,
-    Any = 131071
-}
-declare type ExactTypeTags = TypeTag.Null | TypeTag.False | TypeTag.True | TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double | TypeTag.Char | TypeTag.String | TypeTag.Array | TypeTag.Dictionary | TypeTag.Module | TypeTag.Function | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Function | TypeTag.Symbol;
+    Typedef = 131072,
+    Any = 262143
+}
+export declare const SingleTonTypeTagsConst: number;
+export declare const UnionDataTypeTagsConst: number;
+export declare const ValueTypeTagsConst: number;
+export declare const ObjectLikeTagsConst: number;
+declare type ExactTypeTags = TypeTag.Null | TypeTag.False | TypeTag.True | TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double | TypeTag.Char | TypeTag.String | TypeTag.Array | TypeTag.Dictionary | TypeTag.Module | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Symbol | TypeTag.Typedef;
 export declare type EnumeratedTypeTags = ExactTypeTags | TypeTag.Never | TypeTag.Any;
 export declare type UnionTypeTags = number;
 interface AbstractValue {
     type: UnionTypeTags;
     value?: unknown;
 }
-export declare type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType;
+export declare type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType | TypedefType;
 declare type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : T & {
     value: NonNullable<T["value"]>;
 } : never;
@@ -121,6 +127,10 @@ export interface ClassType extends AbstractValue {
     type: TypeTag.Class;
     value?: ClassStateNode | ClassStateNode[] | undefined;
 }
+export interface TypedefType extends AbstractValue {
+    type: TypeTag.Typedef;
+    value?: TypedefStateNode | TypedefStateNode[] | undefined;
+}
 export interface ObjectType extends AbstractValue {
     type: TypeTag.Object;
     value?: {
@@ -144,17 +154,38 @@ export interface AnyType extends AbstractValue {
     value?: undefined;
 }
 export declare type SingletonType = NullType | FalseType | TrueType;
+export declare type UnionData = {
+    mask: TypeTag;
+    [TypeTag.Array]?: NonNullable<ArrayType["value"]>;
+    [TypeTag.Dictionary]?: NonNullable<DictionaryType["value"]>;
+    [TypeTag.Module]?: NonNullable<ModuleType["value"]>;
+    [TypeTag.Function]?: NonNullable<FunctionType["value"]>;
+    [TypeTag.Class]?: NonNullable<ClassType["value"]>;
+    [TypeTag.Object]?: NonNullable<ObjectType["value"]>;
+    [TypeTag.Enum]?: NonNullable<EnumType["value"]>;
+};
+export declare type UnionDataKey = Exclude<keyof UnionData, "mask">;
 export interface UnionType extends AbstractValue {
-    value?: undefined;
+    value?: UnionData | undefined;
 }
 export declare type ExactOrUnion = UnionType | ExactTypes;
+export declare type SingleValue = NonNullable<ValueTypes["value"]>;
+declare type TagValue<TAG> = Extract<ValueTypes, {
+    type: TAG;
+}>["value"];
+export declare type ArrayValueType = TagValue<TypeTag.Array>;
+export declare type DictionaryValueType = TagValue<TypeTag.Dictionary>;
+export declare type ObjectValueType = TagValue<TypeTag.Object>;
+export declare type EnumValueType = TagValue<TypeTag.Enum>;
+export declare type TypedefValueType = TagValue<TypeTag.Typedef>;
+export declare type StateDeclValueType = TagValue<TypeTag.Module> | TagValue<TypeTag.Function> | TagValue<TypeTag.Class>;
 export declare function isExact(v: AbstractValue): v is ExactTypes;
 export declare function isUnion(v: AbstractValue): v is UnionType;
 export declare function isSingleton(v: AbstractValue): v is SingletonType;
 export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
-export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
 export declare function cloneType<T extends ExactOrUnion>(t: T): T;
 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 typeFromTypespec(state: ProgramStateAnalysis, ts: mctree.TypeSpecList, stack?: ProgramStateStack | undefined): ExactOrUnion;
 export declare function typeFromLiteral(literal: mctree.Literal): ExactTypes;
 export declare function mcExprFromType(type: ValueTypes): mctree.Expression | null;
@@ -163,4 +194,8 @@ export declare const TruthyTypes: number;
 export declare function mustBeTrue(arg: ExactOrUnion): boolean;
 export declare function mustBeFalse(arg: ExactOrUnion): boolean;
 export declare function display(type: ExactOrUnion): string;
+export declare function hasUnionData(tag: TypeTag): boolean;
+export declare function getObjectValue(t: ExactOrUnion): ObjectType["value"] | null;
+export declare function forEachUnionComponent(v: ExactOrUnion, bits: TypeTag, fn: (tag: UnionDataKey, value: SingleValue | null | undefined) => boolean | void): void;
+export declare function getUnionComponent(v: ExactOrUnion, tag: TypeTag): SingleValue | null;
 export {};

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

@@ -0,0 +1,3 @@
+import { ExactOrUnion, TypeTag } from "./types";
+export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
+export declare function clearValuesUnder(v: ExactOrUnion, tag: TypeTag, clearTag?: boolean): void;

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

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

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.45",
+  "version": "1.1.1",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -21,7 +21,8 @@
     "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 && npm run test-remote-tests",
+    "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",
@@ -34,7 +35,7 @@
     "build/util.cjs",
     "build/sdk-util.cjs",
     "build/api.cjs",
-    "build/src/*.d.ts"
+    "build/src/**/*.d.ts"
   ],
   "author": "markw65",
   "license": "MIT",
@@ -42,14 +43,18 @@
     "@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",

package/build/src/interp-call.d.ts

@@ -1,3 +0,0 @@
-import { ExactOrUnion } from "./mc-types";
-import { ProgramStateAnalysis } from "./optimizer-types";
-export declare function evaluateCall(state: ProgramStateAnalysis, callee: ExactOrUnion, _args: ExactOrUnion[]): ExactOrUnion;