@markw65/monkeyc-optimizer 1.1.32 → 1.1.34

package/build/src/src/ast.d.ts

@@ -0,0 +1,59 @@
+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, parent: mctree.Node | undefined) => void | null | false | mctree.Node | mctree.Node[], parent?: mctree.Node | undefined): 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 | false): T;
+export declare function withLocDeep<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined | false, inplace?: boolean): T;
+export declare function cloneDeep<T extends mctree.Node>(node: T): T;
+interface NumberLiteral extends mctree.Literal {
+    value: number;
+}
+interface LongLiteral extends mctree.Literal {
+    value: number | bigint;
+}
+interface StringLiteral extends mctree.Literal {
+    value: string;
+}
+interface CharLiteral extends mctree.Literal {
+    value: string;
+}
+interface BooleanLiteral extends mctree.Literal {
+    value: boolean;
+}
+interface NullLiteral extends mctree.Literal {
+    value: null;
+}
+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/src/build.d.ts

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

package/build/src/src/cftinfo.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+export declare function getCFTFontInfoFromBuffer(name: string, data: Buffer): {
+    name: string;
+    height: number;
+    ascent: number;
+    internalLeading: number;
+    charInfo: {
+        code: number;
+        char: string;
+        width: number;
+    }[];
+};
+export declare function getCFTFontInfo(filename: string): Promise<{
+    name: string;
+    height: number;
+    ascent: number;
+    internalLeading: number;
+    charInfo: {
+        code: number;
+        char: string;
+        width: number;
+    }[];
+}>;
+export declare function getDeviceFontInfo(dirname: string): Promise<{
+    device: string;
+    fontSets: {
+        [k: string]: {
+            [k: string]: string;
+        };
+    };
+    langMap: Record<string, string>;
+}>;

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

@@ -0,0 +1,22 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateAnalysis, FunctionStateNode } from "./optimizer-types";
+export type BaseEvent = {
+    type: string;
+    mayThrow: boolean;
+};
+type EventConstraint<_T> = BaseEvent;
+export type Block<T extends EventConstraint<T>> = {
+    node?: mctree.Node;
+    preds?: Block<T>[];
+    succs?: Block<T>[];
+    expreds?: Block<T>[];
+    exsucc?: Block<T>;
+    bogopred?: Block<T>;
+    events?: T[];
+};
+export declare function buildReducedGraph<T extends EventConstraint<T>>(state: ProgramStateAnalysis, func: FunctionStateNode, refsForUpdate: boolean, notice: (node: mctree.Node, stmt: mctree.Node, mayThrow: boolean | 1, containedEvents: () => T[]) => T | 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/src/data-flow.d.ts

@@ -0,0 +1,107 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { BaseEvent, Block } from "./control-flow";
+import { FunctionStateNode, ProgramStateAnalysis, StateNodeDecl } from "./optimizer-types";
+import { GenericQueue } from "./util";
+export type RefNode = mctree.Identifier | mctree.MemberExpression | mctree.Literal;
+export type MemberDecl = {
+    type: "MemberDecl";
+    node: mctree.MemberExpression;
+    base: StateNodeDecl | StateNodeDecl[];
+    path: mctree.MemberExpression[];
+};
+export type EventDecl = StateNodeDecl | StateNodeDecl[] | mctree.Literal | MemberDecl | {
+    type: "Unknown";
+    node: mctree.MemberExpression | mctree.Identifier | mctree.ThisExpression;
+};
+export interface RefEvent extends BaseEvent {
+    type: "ref";
+    node: RefNode;
+    decl: EventDecl;
+}
+export interface KillEvent extends BaseEvent {
+    type: "kil";
+    node: mctree.Node;
+    decl: StateNodeDecl | StateNodeDecl[];
+}
+export interface DefEvent extends BaseEvent {
+    type: "def";
+    node: mctree.AssignmentExpression | mctree.UpdateExpression | mctree.VariableDeclarator;
+    decl: EventDecl;
+    rhs?: EventDecl;
+    containedEvents?: Array<RefEvent | ModEvent>;
+}
+export interface ModEvent extends BaseEvent {
+    type: "mod";
+    node: mctree.Node;
+    decl?: EventDecl | undefined | null;
+    before?: boolean;
+    id?: RefNode;
+    callees?: FunctionStateNode[] | null;
+    calleeDecl?: EventDecl | undefined;
+    calleeObj?: EventDecl | undefined;
+}
+export declare enum FlowKind {
+    LEFT_EQ_RIGHT_DECL = 0,
+    LEFT_NE_RIGHT_DECL = 1,
+    LEFT_EQ_RIGHT_NODE = 2,
+    LEFT_NE_RIGHT_NODE = 3,
+    LEFT_TRUTHY = 4,
+    LEFT_FALSEY = 5,
+    INSTANCEOF = 6,
+    NOTINSTANCE = 7
+}
+export interface FlowEventDecl extends BaseEvent {
+    type: "flw";
+    node: mctree.BinaryExpression | mctree.UnaryExpression;
+    decl?: undefined;
+    kind: FlowKind.LEFT_EQ_RIGHT_DECL | FlowKind.LEFT_NE_RIGHT_DECL;
+    left: EventDecl;
+    right_decl: EventDecl;
+    right_node?: undefined;
+}
+export interface FlowEventNode extends BaseEvent {
+    type: "flw";
+    node: mctree.BinaryExpression | mctree.UnaryExpression;
+    decl?: undefined;
+    kind: FlowKind.LEFT_EQ_RIGHT_NODE | FlowKind.LEFT_NE_RIGHT_NODE;
+    left: EventDecl;
+    right_decl?: undefined;
+    right_node: mctree.Expression;
+}
+export interface FlowEventTruthy extends BaseEvent {
+    type: "flw";
+    node: mctree.Node;
+    decl?: undefined;
+    kind: FlowKind.LEFT_TRUTHY | FlowKind.LEFT_FALSEY;
+    left: EventDecl;
+    right_decl?: undefined;
+    right_node?: undefined;
+}
+export interface FlowEventInstanceof extends BaseEvent {
+    type: "flw";
+    node: mctree.InstanceofExpression | mctree.UnaryExpression;
+    decl?: undefined;
+    kind: FlowKind.INSTANCEOF | FlowKind.NOTINSTANCE;
+    left: EventDecl;
+    right_decl: EventDecl;
+    right_node?: undefined;
+}
+export type FlowEvent = FlowEventDecl | FlowEventNode | FlowEventTruthy | FlowEventInstanceof;
+export interface ExnEvent extends BaseEvent {
+    type: "exn";
+    node: mctree.Node;
+}
+export type Event = RefEvent | KillEvent | DefEvent | ModEvent | FlowEvent | ExnEvent;
+export interface DataFlowBlock extends Block<Event> {
+    order?: number;
+}
+export declare function declFullName(decl: EventDecl): 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): {
+    identifiers: Set<string>;
+    graph: Block<Event>;
+};
+export declare class DataflowQueue extends GenericQueue<DataFlowBlock> {
+    constructor();
+}

package/build/src/src/driver.d.ts

@@ -0,0 +1,2 @@
+export declare function driver(): Promise<void>;
+export declare function error(message: string): never;

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

@@ -0,0 +1,14 @@
+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;
+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[];
+export declare function findCalleesByNode(state: ProgramStateAnalysis, callee: mctree.Expression): FunctionStateNode[] | null;

package/build/src/src/inliner.d.ts

@@ -0,0 +1,13 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+export declare function inlinableSubExpression(expr: mctree.Expression): mctree.SimpleCallExpression | null;
+export declare function inlineRequested(state: ProgramStateAnalysis, func: FunctionStateNode): boolean;
+export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): boolean;
+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 inlineDiagnostic(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, message: string | null): void;
+export 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;
+export {};

package/build/src/src/jungles.d.ts

@@ -0,0 +1,66 @@
+import { ManifestXML } from "./manifest";
+import { BuildConfig } from "./optimizer-types.js";
+import { DeviceInfo, xmlUtil } from "./sdk-util";
+export type JungleBuildDependencies = Record<string, xmlUtil.Document | true>;
+export type JungleError = Error & {
+    buildDependencies?: JungleBuildDependencies;
+};
+export type Target = {
+    product: string;
+    qualifier: JungleQualifier;
+    shape?: string;
+    group?: {
+        optimizerConfig: JungleQualifier;
+        dir?: string;
+        key: string;
+    };
+};
+type LangResourcePaths = {
+    [key: string]: string[];
+};
+type BarrelAnnotations = {
+    [key: string]: string[];
+};
+type BarrelMap = {
+    [key: string]: ResolvedBarrel;
+};
+type OptBarrelMap = Record<string, {
+    rawBarrelDir: string;
+    manifest: string;
+    jungleFiles: string[];
+    optBarrelDir: string;
+}>;
+export type JungleQualifier = {
+    sourcePath?: string[];
+    sourceExcludes?: string[];
+    excludeAnnotations?: string[];
+    resourcePath?: string[];
+    personality?: string[];
+    lang?: LangResourcePaths;
+    barrelPath?: (string | string[])[];
+    annotations?: BarrelAnnotations;
+    barrelMap?: BarrelMap;
+    optBarrels?: OptBarrelMap;
+    resourceMap?: JungleResourceMap;
+    products?: string[];
+};
+type JungleInfoBase = {
+    jungles: string[];
+    manifest: string;
+    xml: ManifestXML;
+    annotations?: string[];
+    resources: JungleResourceMap;
+    buildDependencies: JungleBuildDependencies;
+    devices: DeviceInfo;
+};
+export type JungleResourceMap = Record<string, xmlUtil.Document>;
+export type ResolvedJungle = JungleInfoBase & {
+    targets: Target[];
+    typeCheckLevel?: string;
+    optimizationLevel?: string;
+};
+export type ResolvedBarrel = JungleInfoBase & {
+    qualifier: JungleQualifier;
+};
+export declare function get_jungle(jungles: string, options: BuildConfig, resources?: JungleResourceMap | undefined): Promise<ResolvedJungle>;
+export {};

package/build/src/src/launch.d.ts

@@ -0,0 +1,5 @@
+import { LineHandler } from "./util";
+export declare function launchSimulator(force?: boolean): Promise<void>;
+export declare function checkIfSimulatorRunning(): Promise<boolean>;
+export declare function checkIfSimulatorRunningOn(port: number): Promise<boolean>;
+export declare function simulateProgram(prg: string, device: string, test?: boolean | string, logger?: LineHandler | LineHandler[]): Promise<void>;

package/build/src/src/logger.d.ts

@@ -0,0 +1,6 @@
+export declare function logger(module: string, level: number, message: unknown): void;
+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 function setLogger(log: (message: string) => void): void;

package/build/src/src/manifest.d.ts

@@ -0,0 +1,11 @@
+import { xmlUtil } from "./sdk-util";
+export type ManifestXML = xmlUtil.Document;
+export declare function readManifest(manifest: string): Promise<ManifestXML>;
+export declare function writeManifest(filename: string, xml: ManifestXML): Promise<void>;
+export declare function manifestProducts(manifest: ManifestXML): string[];
+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/src/mc-rewrite.d.ts

@@ -0,0 +1,13 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { JungleResourceMap } from "./jungles";
+import { BuildConfig, 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>;
+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 optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document, config: BuildConfig): Promise<{
+    diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
+    sdkVersion: number | undefined;
+}>;

package/build/src/src/negative-fixups.d.ts

@@ -0,0 +1 @@
+export declare const negativeFixups: string[];

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

@@ -0,0 +1,249 @@
+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 type DiagnosticType = "ERROR" | "WARNING" | "INFO";
+export type LookupRules = "COMPILER1" | "COMPILER2" | "DEFAULT";
+export type EnforceStatic = "YES" | "NO";
+export type BuildConfig = {
+    workspace?: string;
+    jungleFiles?: string;
+    developerKeyPath?: string;
+    typeCheckLevel?: string;
+    optimizationLevel?: 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";
+    checkCompilerLookupRules?: DiagnosticType | "OFF";
+    compilerLookupRules?: LookupRules;
+    enforceStatic?: EnforceStatic;
+    sizeBasedPRE?: boolean | string;
+    prettier?: Record<string, unknown>;
+    extensionVersion?: string;
+    useLocalOptimizer?: boolean;
+    propagateTypes?: boolean;
+    trustDeclaredTypes?: boolean;
+    minimizeLocals?: boolean;
+    minimizeModules?: boolean;
+    postBuildOptimizer?: boolean;
+    singleUseCopyProp?: boolean;
+    iterateOptimizer?: boolean;
+    covarianceWarnings?: boolean;
+    checkTypes?: DiagnosticType | "OFF";
+    removeArgc?: boolean;
+    postBuildPRE?: boolean;
+};
+export type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier;
+export type StateNodeDecls = {
+    [key: string]: StateNodeDecl[];
+};
+export type ImportUsing = {
+    node: mctree.Using | mctree.ImportModule;
+    module?: ModuleStateNode | null | undefined;
+};
+export declare const enum StateNodeAttributes {
+    NONE = 0,
+    PUBLIC = 1,
+    PROTECTED = 2,
+    PRIVATE = 4,
+    STATIC = 8
+}
+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;
+    attributes: StateNodeAttributes;
+}
+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;
+    superClasses?: Set<StateNode>;
+}
+export 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;
+    info?: FunctionInfo | false;
+    next_info?: FunctionInfo;
+}
+export interface BlockStateNode extends BaseStateNode {
+    type: "BlockStatement";
+    name: undefined;
+    fullName: string;
+    node: mctree.BlockStatement | mctree.ForStatement;
+    stack?: undefined;
+}
+export interface TypedefStateNode extends BaseStateNode {
+    type: "TypedefDeclaration";
+    node: mctree.TypedefDeclaration;
+    name: string;
+    fullName: string;
+    isExpanding?: true;
+    isRecursive?: true;
+    resolvedType?: ExactOrUnion;
+}
+export interface VariableStateNode extends BaseStateNode {
+    type: "VariableDeclarator";
+    node: mctree.VariableDeclarator;
+    name: string;
+    fullName: string;
+    stack: ProgramStateStack;
+    used?: true;
+    resolvedType?: ExactOrUnion | undefined;
+}
+export interface EnumStateNode extends BaseStateNode {
+    type: "EnumDeclaration";
+    node: mctree.EnumDeclaration;
+    name: string;
+    fullName: string;
+    stack: ProgramStateStack;
+    resolvedType?: ExactOrUnion;
+}
+interface DiagnosticBase {
+    loc: mctree.SourceLocation;
+    message: string;
+}
+export interface DiagnosticInfo extends DiagnosticBase {
+    loc: Finalized<mctree.SourceLocation, "source">;
+}
+export interface Diagnostic extends DiagnosticBase {
+    type: DiagnosticType;
+    related?: DiagnosticInfo[];
+    extra?: {
+        uri: string;
+        message: string;
+    };
+}
+type ProgramStateStackElem = {
+    sn: StateNode;
+    usings?: Record<string, ImportUsing>;
+    imports?: ImportUsing[];
+};
+export type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode | EnumStateNode;
+export type ProgramStateStack = ProgramStateStackElem[];
+export type LookupDefinition = {
+    parent: StateNode | null;
+    results: StateNodeDecl[];
+};
+export type LookupResult = [string, LookupDefinition[]] | [null, null] | [false, false];
+export type ByNameStateNodeDecls = ModuleStateNode | ClassStateNode | FunctionStateNode | ProgramStateNode;
+export type ProgramState = {
+    allFunctions?: Record<string, FunctionStateNode[]>;
+    allClasses?: ClassStateNode[];
+    invokeInfo?: FunctionInfo;
+    allDeclarations?: Record<string, ByNameStateNodeDecls[]>;
+    fnMap?: FilesToOptimizeMap;
+    rezAst?: mctree.Program;
+    manifestXML?: xmlUtil.Document;
+    stack?: ProgramStateStack;
+    top?: () => ProgramStateStackElem;
+    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 | null) => LookupResult;
+    lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
+    lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
+    lookupNonlocal?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
+    stackClone?: () => ProgramStateStack;
+    traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
+    inType?: number;
+    inlining?: true;
+    config?: BuildConfig;
+    sdk?: string;
+    sdkVersion?: number;
+    lookupRules?: LookupRules;
+    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, Diagnostic[]>;
+    inlineDiagnostics?: Record<string, Diagnostic[]>;
+    enumMap?: Map<EnumStringMember, EnumStateNode>;
+};
+export type Finalized<T, Keys extends keyof T> = T & {
+    [key in Keys]-?: NonNullable<T[key]>;
+};
+export type ProgramStateLive = Finalized<ProgramState, "stack" | "top" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
+export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap" | "allDeclarations" | "invokeInfo">;
+export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
+export type ExcludeAnnotationsMap = {
+    [key: string]: boolean;
+};
+export type FilesToOptimizeMap = {
+    [key: string]: {
+        output: string;
+        barrel: string;
+        excludeAnnotations: ExcludeAnnotationsMap;
+        monkeyCSource?: string;
+        ast?: mctree.Program;
+        parserError?: Error;
+        hasTests?: boolean;
+    };
+};
+export {};