@markw65/monkeyc-optimizer 1.0.28 → 1.0.31

package/build/src/api.d.ts

@@ -1,13 +1,15 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { traverseAst } from "./ast";
+import { hasProperty, traverseAst } from "./ast";
+import { LookupDefinition, ProgramState, ProgramStateLive, ProgramStateNode, StateNode, StateNodeDecl, ProgramStateStack, FunctionInfo, FunctionStateNode } from "./optimizer-types";
 export { visitReferences } from "./visitor";
-export { traverseAst };
+export { traverseAst, hasProperty };
 export declare function getApiMapping(state?: ProgramState, barrelList?: string[]): Promise<ProgramStateNode | null>;
-export declare function hasProperty<T extends null extends T ? unknown : undefined extends T ? unknown : never>(obj: T, prop: string): obj is NonNullable<T>;
-export declare function hasProperty<T>(obj: T, prop: string): boolean;
 export declare function isStateNode(node: StateNodeDecl): node is StateNode;
 export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
 export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function isLookupCandidate(node: mctree.MemberExpression): false | mctree.Identifier;
 export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
 export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null): string;
 export declare function findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier, isType: boolean): StateNodeDecl[] | null;
+export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo;
+export declare function markInvokeClassMethod(func: FunctionStateNode): void;

package/build/src/ast.d.ts

@@ -1,2 +1,10 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 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;
+export declare function mayThrow(node: mctree.Node): boolean;
+export declare function hasProperty<T extends null extends T ? unknown : undefined extends T ? unknown : never>(obj: T, prop: string): obj is NonNullable<T>;
+export declare function hasProperty<T>(obj: T, prop: string): boolean;
+export declare function withLoc<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined): T;
+export declare function withLocDeep<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined, inplace?: boolean): T;
+export declare function cloneDeep<T extends mctree.Node>(node: T): T;

package/build/src/build.d.ts

@@ -1,3 +1,4 @@
+import { BuildConfig } from "./optimizer-types";
 export declare function build_project(product: string | null, options: BuildConfig, lineCallback?: (line: string) => void): Promise<{
     exe: string;
     args: string[];

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

@@ -0,0 +1,21 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateAnalysis, FunctionStateNode } from "./optimizer-types";
+export declare type BaseEvent = {
+    type: string;
+    mayThrow: boolean;
+};
+declare type EventConstraint<_T> = BaseEvent;
+export declare type Block<T extends EventConstraint<T>> = {
+    node?: mctree.Node;
+    preds?: Block<T>[];
+    succs?: Block<T>[];
+    expreds?: Block<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 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>[];
+export declare function getPreOrder<T extends EventConstraint<T>>(head: Block<T>): Block<T>[];
+export {};

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

@@ -0,0 +1,12 @@
+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;
+export declare function recordModifiedDecl(func: FunctionStateNode, decl: VariableStateNode): null;
+export declare function recordModifiedDecls(func: FunctionStateNode, lookupDefs: LookupDefinition[]): void;
+export declare function recordModifiedName(func: FunctionStateNode, name: string): void;
+export declare function recordModifiedUnknown(func: FunctionStateNode): void;
+export declare function recordCalledFunc(func: FunctionStateNode, callee: FunctionStateNode): null;
+export declare function recordCalledFuncs(func: FunctionStateNode, callees: FunctionStateNode[]): void;
+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[];

package/build/src/inliner.d.ts

@@ -1,10 +1,11 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis, ProgramStateLive } from "./optimizer-types";
 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(expression: mctree.ExpressionStatement["expression"]): mctree.ExpressionStatement[];
-export declare function unused(expression: mctree.ExpressionStatement["expression"], top: true): mctree.ExpressionStatement[] | null;
+export declare function unused(expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];
+export declare function unused(expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | null;
 export declare function diagnostic(state: ProgramStateLive, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
-export declare type InlineContext = mctree.ReturnStatement | mctree.AssignmentExpression | mctree.ExpressionStatement;
+export declare type InlineContext = mctree.ReturnStatement | 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;
 export {};

package/build/src/jungles.d.ts

@@ -1,4 +1,5 @@
 import { ManifestXML } from "./manifest";
+import { BuildConfig } from "./optimizer-types.js";
 export declare type Target = {
     product: string;
     qualifier: JungleQualifier;

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

@@ -1,11 +1,12 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { BuildConfig, FilesToOptimizeMap, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
 export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
 export declare function analyze(fnMap: FilesToOptimizeMap, barrelList?: string[], config?: BuildConfig): Promise<ProgramStateAnalysis>;
-export declare function getLiteralFromDecls(lookupDefns: LookupDefinition[]): null;
+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, barrelList?: string[], config?: BuildConfig): Promise<Record<string, {
-    type: DiagnosticType;
+    type: "ERROR" | "WARNING" | "INFO";
     loc: {
         start: mctree.Position;
         end: mctree.Position;

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

@@ -0,0 +1,188 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ResolvedJungle } from "./jungles";
+declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
+export declare type BuildConfig = {
+    workspace?: string;
+    jungleFiles?: string;
+    developerKeyPath?: string;
+    typeCheckLevel?: string;
+    compilerOptions?: string;
+    compilerWarnings?: boolean;
+    simulatorBuild?: boolean;
+    releaseBuild?: boolean;
+    testBuild?: boolean;
+    products?: string[];
+    buildDir?: string;
+    outputPath?: string;
+    program?: string;
+    skipOptimization?: boolean;
+    checkManifest?: boolean;
+    device?: string;
+    ignoredExcludeAnnotations?: string;
+    ignoredAnnotations?: string;
+    ignoredSourcePaths?: string;
+    returnCommand?: boolean;
+    checkBuildPragmas?: boolean;
+    checkInvalidSymbols?: DiagnosticType | "OFF";
+    sizeBasedPRE?: boolean | string;
+    _cache?: {
+        barrels?: Record<string, ResolvedJungle>;
+        barrelMap?: Record<string, Record<string, ResolvedJungle>>;
+    };
+};
+export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
+export declare type StateNodeDecls = {
+    [key: string]: StateNodeDecl[];
+};
+export declare type ImportUsing = {
+    node: mctree.Using | mctree.ImportModule;
+    module?: ModuleStateNode | null | undefined;
+};
+interface BaseStateNode {
+    type: string;
+    node: mctree.Node | null | undefined;
+    name: string | null | undefined;
+    fullName: string | null | undefined;
+    decls?: StateNodeDecls | undefined;
+    type_decls?: StateNodeDecls | undefined;
+    stack?: ProgramStateStack | undefined;
+    usings?: Record<string, ImportUsing>;
+    imports?: ImportUsing[];
+}
+export interface ProgramStateNode extends BaseStateNode {
+    type: "Program";
+    node: mctree.Program | undefined;
+    name: "$";
+    fullName: "$";
+    stack?: undefined;
+}
+export interface ModuleStateNode extends BaseStateNode {
+    type: "ModuleDeclaration";
+    node: mctree.ModuleDeclaration;
+    name: string;
+    fullName: string;
+}
+export interface ClassStateNode extends BaseStateNode {
+    type: "ClassDeclaration";
+    node: mctree.ClassDeclaration;
+    name: string;
+    fullName: string;
+    superClass?: ClassStateNode[] | true;
+    hasInvoke?: boolean;
+}
+export declare type FunctionInfo = {
+    modifiedDecls: Set<VariableStateNode>;
+    calledFuncs: Set<FunctionStateNode>;
+    resolvedDecls?: Set<VariableStateNode>;
+    callsExposed?: boolean;
+    modifiedUnknown?: boolean;
+    modifiedNames?: Set<string>;
+};
+export interface FunctionStateNode extends BaseStateNode {
+    type: "FunctionDeclaration";
+    node: mctree.FunctionDeclaration;
+    name: string;
+    fullName: string;
+    stack?: ProgramStateStack;
+    decls?: undefined;
+    isStatic?: boolean;
+    info?: FunctionInfo;
+    next_info?: FunctionInfo;
+}
+export interface BlockStateNode extends BaseStateNode {
+    type: "BlockStatement";
+    name: undefined;
+    fullName: undefined;
+    node: mctree.BlockStatement | mctree.ForStatement;
+    stack?: undefined;
+}
+export interface TypedefStateNode extends BaseStateNode {
+    type: "TypedefDeclaration";
+    node: mctree.TypedefDeclaration;
+    name: string;
+    fullName: string;
+}
+export interface VariableStateNode extends BaseStateNode {
+    type: "VariableDeclarator";
+    node: mctree.VariableDeclarator;
+    name: string;
+    fullName: string;
+    stack: ProgramStateStack;
+    used?: true;
+}
+export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode;
+export declare type ProgramStateStack = StateNode[];
+export declare type LookupDefinition = {
+    parent: StateNode | null;
+    results: StateNodeDecl[];
+};
+export declare type LookupResult = [string, LookupDefinition[]] | [null, null] | [false, false];
+export declare type ProgramState = {
+    allFunctions?: Record<string, FunctionStateNode[]>;
+    allClasses?: ClassStateNode[];
+    fnMap?: FilesToOptimizeMap;
+    stack?: ProgramStateStack;
+    currentFunction?: FunctionStateNode;
+    removeNodeComments?: (node: mctree.Node, ast: mctree.Program) => void;
+    shouldExclude?: (node: mctree.Node) => boolean;
+    pre?: (node: mctree.Node, state: ProgramStateLive) => null | false | (keyof mctree.NodeAll)[];
+    post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node | mctree.Node[];
+    lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
+    lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
+    lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
+    lookupNonlocal?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
+    stackClone?: () => ProgramStateStack;
+    traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
+    inType?: number;
+    inlining?: true;
+    config?: BuildConfig;
+    nextExposed?: Record<string, true>;
+    exposed?: Record<string, true>;
+    usedByName?: Record<string, true>;
+    calledFunctions?: {
+        [key: string]: mctree.FunctionDeclaration[];
+    };
+    localsStack?: {
+        node?: mctree.Node;
+        map?: {
+            [key: string]: boolean | string;
+        };
+        inners?: {
+            [key: string]: true;
+        };
+    }[];
+    index?: {
+        [key: string]: unknown[];
+    };
+    constants?: {
+        [key: string]: mctree.Literal;
+    };
+    diagnostics?: Record<string, {
+        type: DiagnosticType;
+        loc: {
+            start: mctree.Position;
+            end: mctree.Position;
+        };
+        message: string;
+    }[]>;
+};
+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">;
+export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap">;
+export declare type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
+export declare type ExcludeAnnotationsMap = {
+    [key: string]: boolean;
+};
+export declare type FilesToOptimizeMap = {
+    [key: string]: {
+        output: string;
+        excludeAnnotations: ExcludeAnnotationsMap;
+        monkeyCSource?: string;
+        ast?: mctree.Program;
+        parserError?: Error;
+        hasTests?: boolean;
+    };
+};
+export {};

package/build/src/optimizer.d.ts

@@ -3,6 +3,8 @@ import { get_jungle, ResolvedJungle, Target } from "./jungles";
 import { launchSimulator, simulateProgram } from "./launch";
 import { manifestProducts } from "./manifest";
 import { copyRecursiveAsNeeded } from "./util";
+import { BuildConfig, FilesToOptimizeMap, ProgramStateAnalysis } from "./optimizer-types";
+export * from "./optimizer-types";
 export { copyRecursiveAsNeeded, get_jungle, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, };
 export declare const defaultConfig: {
     outputPath: string;
@@ -13,177 +15,6 @@ export interface ErrorWithLocation extends Error {
 }
 export declare function isErrorWithLocation(e: Error): e is ErrorWithLocation;
 declare global {
-    type DiagnosticType = "ERROR" | "WARNING" | "INFO";
-    type BuildConfig = {
-        workspace?: string;
-        jungleFiles?: string;
-        developerKeyPath?: string;
-        typeCheckLevel?: string;
-        compilerOptions?: string;
-        compilerWarnings?: boolean;
-        simulatorBuild?: boolean;
-        releaseBuild?: boolean;
-        testBuild?: boolean;
-        products?: string[];
-        buildDir?: string;
-        outputPath?: string;
-        program?: string;
-        skipOptimization?: boolean;
-        checkManifest?: boolean;
-        device?: string;
-        ignoredExcludeAnnotations?: string;
-        ignoredAnnotations?: string;
-        ignoredSourcePaths?: string;
-        returnCommand?: boolean;
-        checkBuildPragmas?: boolean;
-        checkInvalidSymbols?: DiagnosticType | "OFF";
-        _cache?: {
-            barrels?: Record<string, ResolvedJungle>;
-            barrelMap?: Record<string, Record<string, ResolvedJungle>>;
-        };
-    };
-    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
-    type StateNodeDecls = {
-        [key: string]: StateNodeDecl[];
-    };
-    type ImportUsing = {
-        node: mctree.Using | mctree.ImportModule;
-        module?: ModuleStateNode | null | undefined;
-    };
-    interface BaseStateNode {
-        type: string;
-        node: mctree.Node | null | undefined;
-        name: string | null | undefined;
-        fullName: string | null | undefined;
-        decls?: StateNodeDecls | undefined;
-        type_decls?: StateNodeDecls | undefined;
-        stack?: ProgramStateStack | undefined;
-        usings?: Record<string, ImportUsing>;
-        imports?: ImportUsing[];
-    }
-    interface ProgramStateNode extends BaseStateNode {
-        type: "Program";
-        node: mctree.Program | undefined;
-        name: "$";
-        fullName: "$";
-        stack?: undefined;
-    }
-    interface ModuleStateNode extends BaseStateNode {
-        type: "ModuleDeclaration";
-        node: mctree.ModuleDeclaration;
-        name: string;
-        fullName: string;
-    }
-    interface ClassStateNode extends BaseStateNode {
-        type: "ClassDeclaration";
-        node: mctree.ClassDeclaration;
-        name: string;
-        fullName: string;
-        superClass?: ClassStateNode[] | true;
-    }
-    interface FunctionStateNode extends BaseStateNode {
-        type: "FunctionDeclaration";
-        node: mctree.FunctionDeclaration;
-        name: string;
-        fullName: string;
-        stack?: ProgramStateStack;
-        decls?: undefined;
-        isStatic?: boolean;
-    }
-    interface BlockStateNode extends BaseStateNode {
-        type: "BlockStatement";
-        name: undefined;
-        fullName: undefined;
-        node: mctree.BlockStatement;
-        stack?: undefined;
-    }
-    interface TypedefStateNode extends BaseStateNode {
-        type: "TypedefDeclaration";
-        node: mctree.TypedefDeclaration;
-        name: string;
-        fullName: string;
-    }
-    interface VariableStateNode extends BaseStateNode {
-        type: "VariableDeclarator";
-        node: mctree.VariableDeclarator;
-        name: string;
-        fullName: string;
-        stack: ProgramStateStack;
-    }
-    type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode;
-    type ProgramStateStack = StateNode[];
-    type LookupDefinition = {
-        parent: StateNodeDecl | null;
-        results: StateNodeDecl[];
-    };
-    type LookupResult = [string, LookupDefinition[]] | [null, null] | [false, false];
-    export type ProgramState = {
-        allFunctions?: FunctionStateNode[];
-        allClasses?: ClassStateNode[];
-        fnMap?: FilesToOptimizeMap;
-        stack?: ProgramStateStack;
-        removeNodeComments?: (node: mctree.Node, ast: mctree.Program) => void;
-        shouldExclude?: (node: mctree.Node) => boolean;
-        pre?: (node: mctree.Node, state: ProgramStateLive) => null | false | (keyof mctree.NodeAll)[];
-        post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node | mctree.Node[];
-        lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
-        lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
-        lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
-        lookupNonlocal?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => LookupResult;
-        stackClone?: () => ProgramStateStack;
-        traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
-        inType?: boolean;
-        inlining?: true;
-        config?: BuildConfig;
-        exposed?: {
-            [key: string]: true;
-        };
-        calledFunctions?: {
-            [key: string]: mctree.FunctionDeclaration[];
-        };
-        localsStack?: {
-            node?: mctree.Node;
-            map?: {
-                [key: string]: boolean | string;
-            };
-            inners?: {
-                [key: string]: true;
-            };
-        }[];
-        index?: {
-            [key: string]: unknown[];
-        };
-        constants?: {
-            [key: string]: mctree.Literal;
-        };
-        diagnostics?: Record<string, {
-            type: DiagnosticType;
-            loc: {
-                start: mctree.Position;
-                end: mctree.Position;
-            };
-            message: string;
-        }[]>;
-    };
-    type Finalized<T, Keys extends keyof T> = T & {
-        [key in Keys]-?: NonNullable<T[key]>;
-    };
-    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType">;
-    export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap">;
-    export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions">;
-    type ExcludeAnnotationsMap = {
-        [key: string]: boolean;
-    };
-    type FilesToOptimizeMap = {
-        [key: string]: {
-            output: string;
-            excludeAnnotations: ExcludeAnnotationsMap;
-            monkeyCSource?: string;
-            ast?: mctree.Program;
-            parserError?: Error;
-            hasTests?: boolean;
-        };
-    };
     var lastModifiedSource: number;
 }
 /**
@@ -199,7 +30,7 @@ export declare function buildOptimizedProject(product: string | null, options: B
     product: string | null;
     hasTests: boolean;
     diagnostics: Record<string, {
-        type: DiagnosticType;
+        type: "ERROR" | "WARNING" | "INFO";
         loc: {
             start: mctree.Position;
             end: mctree.Position;
@@ -219,7 +50,7 @@ export declare function generateOptimizedProject(options: BuildConfig): Promise<
     program: string;
     hasTests: boolean;
     diagnostics: Record<string, {
-        type: DiagnosticType;
+        type: "ERROR" | "WARNING" | "INFO";
         loc: {
             start: mctree.Position;
             end: mctree.Position;

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

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

package/build/src/pre.d.ts

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

package/build/src/unused-exprs.d.ts

@@ -0,0 +1,3 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateOptimizer } from "./optimizer-types";
+export declare function cleanupUnusedVars(state: ProgramStateOptimizer, node: mctree.BlockStatement | mctree.ForStatement): void;

package/build/src/variable-renamer.d.ts

@@ -1 +1,2 @@
+import { ProgramStateAnalysis } from "./optimizer-types";
 export declare function renameVariable(state: ProgramStateAnalysis, locals: NonNullable<ProgramStateAnalysis["localsStack"]>[number], declName: string): string | null;

package/build/src/visitor.d.ts

@@ -1,2 +1,3 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 export declare function visitReferences(state: ProgramStateAnalysis, ast: mctree.Program, name: string | null, defn: LookupDefinition[] | null | false, callback: (node: mctree.Node, results: LookupDefinition[], error: boolean) => undefined | false): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.28",
+  "version": "1.0.31",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -37,11 +37,12 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.29"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.33"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",
     "@types/prettier": "^2.6.1",
+    "@types/priorityqueuejs": "^1.0.1",
     "@types/xml2js": "^0.4.11",
     "@typescript-eslint/eslint-plugin": "^5.28.0",
     "@typescript-eslint/parser": "^5.28.0",
@@ -51,6 +52,7 @@
     "peggy": "^1.2.0",
     "prettier": "^2.6.2",
     "prettier-plugin-pegjs": "^0.5.0",
+    "priorityqueuejs": "^2.0.0",
     "ts-loader": "^9.3.0",
     "typescript": "^4.6.4",
     "webpack": "^5.72.0",