@markw65/monkeyc-optimizer 1.1.2 → 1.1.3

package/build/sdk-util.cjs

@@ -171,7 +171,7 @@ function isMCTreeNode(node) {
  *  - if post returns false, the node it was called on is
  *    removed.
  */
-function traverseAst(node, pre, post) {
+function traverseAst(node, pre, post, parent) {
     const nodes = pre && pre(node);
     if (nodes === false)
         return;
@@ -186,7 +186,7 @@ function traverseAst(node, pre, post) {
             const values = value;
             const deletions = values.reduce((state, obj, i) => {
                 if (isMCTreeNode(obj)) {
-                    const repl = traverseAst(obj, pre, post);
+                    const repl = traverseAst(obj, pre, post, node);
                     if (repl === false) {
                         if (!state)
                             state = {};
@@ -205,7 +205,7 @@ function traverseAst(node, pre, post) {
             }
         }
         else if (isMCTreeNode(value)) {
-            let repl = traverseAst(value, pre, post);
+            let repl = traverseAst(value, pre, post, node);
             if (repl === false) {
                 delete node[key];
             }
@@ -225,7 +225,7 @@ function traverseAst(node, pre, post) {
             }
         }
     }
-    return post && post(node);
+    return post && post(node, parent);
 }
 function isStatement(node) {
     return hasProperty(mctreeTypeInfo[node.type], "stmt");
@@ -270,6 +270,9 @@ function withLoc(node, start, end) {
 }
 function withLocDeep(node, start, end, inplace) {
     node = withLoc(inplace ? node : { ...node }, start, end);
+    if (!inplace && node.origins) {
+        node.origins = [...node.origins];
+    }
     for (const key of mctreeTypeInfo[node.type].keys) {
         const value = node[key];
         if (!value)

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 { ClassStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, VariableStateNode } from "./optimizer-types";
+import { ClassStateNode, Diagnostic, DiagnosticType, 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";
@@ -9,10 +9,14 @@ export { traverseAst, hasProperty, visit_resources };
 export declare function parseSdkVersion(version: string | undefined): number;
 export declare function checkCompilerVersion(version: string, sdkVer: number): boolean | undefined;
 export declare function getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): Promise<ProgramStateNode | null>;
-export declare function isStateNode(node: StateNodeDecl): node is StateNode;
+export declare function isStateNode(node: {
+    type: string;
+}): node is StateNode;
 export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
+declare type DeclKind = "decls" | "type_decls";
 export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
 export declare function isLookupCandidate(node: mctree.MemberExpression): false | mctree.Identifier;
+export declare function lookupNext(state: ProgramStateLive, results: LookupDefinition[], decls: DeclKind, property: mctree.Identifier): LookupDefinition[] | null;
 export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
 export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null, options?: Record<string, unknown> | null): string;
 export declare function findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier): ModuleStateNode | {
@@ -25,5 +29,5 @@ export declare function findUsingForNode(state: ProgramStateLive, stack: Program
 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;
+export declare function diagnostic(state: ProgramState, node: mctree.Node, message: string | null, type?: DiagnosticType, extra?: Diagnostic["extra"]): void;
+export declare function getSuperClasses(klass: ClassStateNode): Set<StateNode> | null;

package/build/src/ast.d.ts

@@ -1,6 +1,6 @@
 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 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;

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

@@ -11,9 +11,10 @@ export declare type Block<T extends EventConstraint<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, notice: (node: mctree.Node, stmt: mctree.Node, mayThrow: boolean | 1) => 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 | 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

@@ -2,16 +2,30 @@ 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 declare type EventDecl = StateNodeDecl | StateNodeDecl[] | mctree.Literal | {
+    type: "MemberDecl";
+    node: mctree.MemberExpression;
+    base: StateNodeDecl | StateNodeDecl[];
+    path: mctree.MemberExpression[];
+} | {
+    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;
 }
 export interface ModEvent extends BaseEvent {
     type: "mod";
@@ -20,21 +34,70 @@ export interface ModEvent extends BaseEvent {
     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
+}
+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;
+}
+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;
+}
+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;
+}
+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 declare type FlowEvent = FlowEventDecl | FlowEventNode | FlowEventTruthy | FlowEventInstanceof;
 export interface ExnEvent extends BaseEvent {
     type: "exn";
     node: mctree.Node;
 }
-export declare type Event = RefEvent | DefEvent | ModEvent | ExnEvent;
+export declare type Event = RefEvent | KillEvent | DefEvent | ModEvent | FlowEvent | ExnEvent;
 export interface DataFlowBlock extends Block<Event> {
     order?: number;
 }
-export declare function declFullName(decl: EventDecl): string | undefined;
+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<RefEvent | DefEvent | ModEvent | ExnEvent>;
+    graph: Block<RefEvent | KillEvent | DefEvent | ModEvent | FlowEventDecl | FlowEventNode | FlowEventTruthy | FlowEventInstanceof | ExnEvent>;
 };
 export declare class DataflowQueue {
     private enqueued;
@@ -43,3 +106,4 @@ export declare class DataflowQueue {
     dequeue(): DataFlowBlock;
     empty(): boolean;
 }
+export {};

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

@@ -7,11 +7,4 @@ 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<Record<string, {
-    type: import("./optimizer-types").DiagnosticType;
-    loc: {
-        start: mctree.Position;
-        end: mctree.Position;
-    };
-    message: string;
-}[]> | undefined>;
+export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document, config: BuildConfig): Promise<Record<string, import("./optimizer-types").Diagnostic[]> | undefined>;

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

@@ -37,6 +37,7 @@ export declare type BuildConfig = {
     useLocalOptimizer?: boolean;
     propagateTypes?: boolean;
     trustDeclaredTypes?: boolean;
+    covarianceWarnings?: boolean;
     checkTypes?: DiagnosticType | "OFF";
 };
 export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier;
@@ -85,7 +86,7 @@ export interface ClassStateNode extends BaseStateNode {
     fullName: string;
     superClass?: ClassStateNode[] | true;
     hasInvoke?: boolean;
-    superClasses?: Set<ClassStateNode>;
+    superClasses?: Set<StateNode>;
 }
 export declare type FunctionInfo = {
     modifiedDecls: Set<VariableStateNode>;
@@ -135,6 +136,22 @@ export interface EnumStateNode extends BaseStateNode {
     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;
+    };
 }
 export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode | EnumStateNode;
 export declare type ProgramStateStack = StateNode[];
@@ -143,10 +160,12 @@ export declare type LookupDefinition = {
     results: StateNodeDecl[];
 };
 export declare type LookupResult = [string, LookupDefinition[]] | [null, null] | [false, false];
+export declare type ByNameStateNodeDecls = ModuleStateNode | ClassStateNode | FunctionStateNode | ProgramStateNode;
 export declare type ProgramState = {
     allFunctions?: Record<string, FunctionStateNode[]>;
     allClasses?: ClassStateNode[];
     invokeInfo?: FunctionInfo;
+    allDeclarations?: Record<string, ByNameStateNodeDecls[]>;
     fnMap?: FilesToOptimizeMap;
     rezAst?: mctree.Program;
     manifestXML?: xmlUtil.Document;
@@ -189,21 +208,14 @@ export declare type ProgramState = {
     constants?: {
         [key: string]: mctree.Literal;
     };
-    diagnostics?: Record<string, {
-        type: DiagnosticType;
-        loc: {
-            start: mctree.Position;
-            end: mctree.Position;
-        };
-        message: string;
-    }[]>;
+    diagnostics?: Record<string, Diagnostic[]>;
     enumMap?: Map<EnumStringMember, EnumStateNode>;
 };
 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" | "invokeInfo">;
+export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap" | "allDeclarations" | "invokeInfo">;
 export declare type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
 export declare type ExcludeAnnotationsMap = {
     [key: string]: boolean;

package/build/src/optimizer.d.ts

@@ -43,14 +43,7 @@ export declare function buildOptimizedProject(product: string | null, options: B
     program: string;
     product: string | null;
     hasTests: boolean;
-    diagnostics: Record<string, {
-        type: import("./optimizer-types").DiagnosticType;
-        loc: {
-            start: mctree.Position;
-            end: mctree.Position;
-        };
-        message: string;
-    }[]> | undefined;
+    diagnostics: Record<string, import("./optimizer-types").Diagnostic[]> | undefined;
 }>;
 export declare function generateOptimizedProject(options: BuildConfig): Promise<{
     jungleFiles: string | undefined;
@@ -63,14 +56,7 @@ export declare function generateOptimizedProject(options: BuildConfig): Promise<
     xml: xmlUtil.Document;
     program: string;
     hasTests: boolean;
-    diagnostics: Record<string, {
-        type: import("./optimizer-types").DiagnosticType;
-        loc: {
-            start: mctree.Position;
-            end: mctree.Position;
-        };
-        message: string;
-    }[]>;
+    diagnostics: Record<string, import("./optimizer-types").Diagnostic[]>;
 }>;
 export declare type PreAnalysis = {
     fnMap: FilesToOptimizeMap;

package/build/src/projects.d.ts

@@ -16,7 +16,7 @@ export declare type RemoteProject = string | {
     test?: boolean;
 };
 export declare const githubProjects: RemoteProject[];
-export declare function fetchGitProjects(projects: RemoteProject[], testOnly: boolean): Promise<(string | {
+export declare function fetchGitProjects(projects: RemoteProject[], testOnly: boolean, skipRemote: boolean): Promise<(string | {
     jungle: string;
     build: boolean | null;
     options: BuildConfig | null;

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

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

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

@@ -0,0 +1,5 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { TypeFlowBlock } from "./type-flow-util";
+export declare function findDeadStores(graph: TypeFlowBlock, logThisRun: boolean): Set<mctree.Node>;
+export declare function eliminateDeadStores(state: ProgramStateAnalysis, func: FunctionStateNode, graph: TypeFlowBlock, logThisRun: boolean): boolean;

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

@@ -1,4 +1,16 @@
-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;
+import { FunctionStateNode } from "src/optimizer-types";
+import { InterpStackElem, InterpState } from "./interp";
+import { ExactOrUnion } from "./types";
+export declare function evaluateCall(istate: InterpState, node: mctree.CallExpression, callee: ExactOrUnion, args: ExactOrUnion[]): InterpStackElem;
+export declare function checkCallArgs(istate: InterpState, node: mctree.CallExpression, callees: FunctionStateNode | FunctionStateNode[], args: ExactOrUnion[]): InterpStackElem;
+declare type SysCallHelperResult = {
+    calleeObj?: ExactOrUnion;
+    returnType?: ExactOrUnion;
+    argTypes?: ExactOrUnion[];
+    effectFree?: true;
+    argEffects?: true;
+};
+declare type SysCallHelper = (func: FunctionStateNode, calleeObj: ExactOrUnion, getArgs: () => Array<ExactOrUnion>) => SysCallHelperResult;
+export declare function sysCallInfo(func: FunctionStateNode): SysCallHelper | null;
+export {};

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

@@ -1,5 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { DiagnosticType, FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
 import { ExactOrUnion } from "./types";
 export declare type TypeMap = Map<mctree.Node, ExactOrUnion>;
 export declare type InterpStackElem = {
@@ -14,10 +14,16 @@ export declare type InterpState = {
     func?: FunctionStateNode;
     pre?: (node: mctree.Node) => mctree.Node | false | null | void;
     post?: (node: mctree.Node) => mctree.Node | false | null | void;
+    typeChecker?: (a: ExactOrUnion, b: ExactOrUnion) => boolean;
+    checkTypes?: DiagnosticType;
 };
 export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
+export declare function tryPop(istate: InterpState, node: InterpStackElem["node"]): InterpStackElem;
 export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;
+export declare function preEvaluate(istate: InterpState, node: mctree.Node): null | (keyof mctree.NodeAll)[];
 export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
 export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
+export declare function deEnumerate(t: ExactOrUnion): ExactOrUnion;
 export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
 export declare function roundToFloat(value: number): number;
+export declare function mustBeIdentical(a: ExactOrUnion, b: ExactOrUnion): boolean;

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

@@ -4,3 +4,4 @@ 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;
+export declare function tryDeEnumerate(istate: InterpState, node: mctree.Expression, elem: number): mctree.Expression | null;

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

@@ -0,0 +1,16 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { DataFlowBlock as TypeFlowBlock, Event, EventDecl } from "../data-flow";
+import { VariableStateNode } from "../optimizer-types";
+export { TypeFlowBlock };
+export declare function isTypeStateKey(decl: EventDecl): decl is TypeStateKey;
+export declare function declIsLocal(decl: EventDecl): decl is VariableStateNode | VariableStateNode[] | mctree.TypedIdentifier;
+export declare function localDeclName(decl: EventDecl): string;
+export declare type TypeStateKey = Exclude<EventDecl, {
+    type: "MemberDecl" | "Unknown";
+}>;
+export declare function tsKey(key: TypeStateKey): string;
+export declare function sourceLocation(loc: mctree.SourceLocation | null | undefined): string;
+export declare function printBlockHeader(block: TypeFlowBlock): void;
+export declare function describeEvent(event: Event): string;
+export declare function printBlockEvents(block: TypeFlowBlock, extra?: (event: Event) => string): void;
+export declare function printBlockTrailer(block: TypeFlowBlock): void;

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

@@ -1,29 +1,6 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl, TypedefStateNode } from "../optimizer-types";
-/**
- * TypeBit gives the position of the 1 bit in TypeTag
- */
-export declare enum TypeBit {
-    Null = 0,
-    False = 1,
-    True = 2,
-    Number = 3,
-    Long = 4,
-    Float = 5,
-    Double = 6,
-    Char = 7,
-    String = 8,
-    Array = 9,
-    Dictionary = 10,
-    Module = 11,
-    Function = 12,
-    Class = 13,
-    Object = 14,
-    Enum = 15,
-    Symbol = 16,
-    Typedef = 17
-}
-export declare enum TypeTag {
+import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode } from "../optimizer-types";
+export declare const enum TypeTag {
     Never = 0,
     Null = 1,
     False = 2,
@@ -33,35 +10,43 @@ export declare enum TypeTag {
     Long = 16,
     Float = 32,
     Double = 64,
+    Decimal = 96,
     Numeric = 120,
     Char = 128,
     String = 256,
     Array = 512,
     Dictionary = 1024,
-    Module = 2048,
-    Function = 4096,
-    Class = 8192,
-    Object = 16384,
-    Enum = 32768,
-    Symbol = 65536,
-    Typedef = 131072,
-    Any = 262143
-}
+    Method = 2048,
+    Module = 4096,
+    Function = 8192,
+    Class = 16384,
+    Object = 32768,
+    Enum = 65536,
+    Symbol = 131072,
+    Typedef = 262144,
+    Any = 524287
+}
+export declare function typeTagName(tag: TypeTag): "Object" | "Number" | "Float" | "Double" | "Long" | "String" | "Char" | "Boolean" | "Null" | "Never" | "False" | "True" | "Decimal" | "Numeric" | "Array" | "Dictionary" | "Method" | "Module" | "Function" | "Class" | "Enum" | "Symbol" | "Typedef" | "Any";
+export declare const LastTypeTag = TypeTag.Typedef;
 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 const EnumTagsConst: 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.Method | 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 | TypedefType;
+export declare type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | MethodType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType | TypedefType;
 declare type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : T & {
     value: NonNullable<T["value"]>;
 } : never;
+export declare type ExactData<T extends ExactTypeTags> = T extends SingletonType ? undefined : NonNullable<Extract<ExactTypes, {
+    type: T;
+}>["value"]>;
 export declare type ValueTypes = WithValue<ExactTypes>;
 export declare type ExtendedTypes = ExactTypes | NeverType | AnyType;
 export interface NeverType extends AbstractValue {
@@ -115,6 +100,13 @@ export interface DictionaryType extends AbstractValue {
         value: ExactOrUnion;
     } | undefined;
 }
+export interface MethodType extends AbstractValue {
+    type: TypeTag.Method;
+    value?: {
+        args: ExactOrUnion[];
+        result: ExactOrUnion;
+    } | undefined;
+}
 export interface ModuleType extends AbstractValue {
     type: TypeTag.Module;
     value?: ModuleStateNode | ModuleStateNode[] | undefined;
@@ -143,6 +135,9 @@ export interface EnumType extends AbstractValue {
     value?: {
         enum: EnumStateNode;
         value?: ExactOrUnion | undefined;
+    } | {
+        enum?: undefined;
+        value: ExactOrUnion;
     } | undefined;
 }
 export interface SymbolType extends AbstractValue {
@@ -150,7 +145,7 @@ export interface SymbolType extends AbstractValue {
     value?: string | undefined;
 }
 export interface AnyType extends AbstractValue {
-    type: -1;
+    type: TypeTag.Any;
     value?: undefined;
 }
 export declare type SingletonType = NullType | FalseType | TrueType;
@@ -158,6 +153,7 @@ export declare type UnionData = {
     mask: TypeTag;
     [TypeTag.Array]?: NonNullable<ArrayType["value"]>;
     [TypeTag.Dictionary]?: NonNullable<DictionaryType["value"]>;
+    [TypeTag.Method]?: NonNullable<MethodType["value"]>;
     [TypeTag.Module]?: NonNullable<ModuleType["value"]>;
     [TypeTag.Function]?: NonNullable<FunctionType["value"]>;
     [TypeTag.Class]?: NonNullable<ClassType["value"]>;
@@ -175,6 +171,7 @@ declare type TagValue<TAG> = Extract<ValueTypes, {
 }>["value"];
 export declare type ArrayValueType = TagValue<TypeTag.Array>;
 export declare type DictionaryValueType = TagValue<TypeTag.Dictionary>;
+export declare type MethodValueType = TagValue<TypeTag.Method>;
 export declare type ObjectValueType = TagValue<TypeTag.Object>;
 export declare type EnumValueType = TagValue<TypeTag.Enum>;
 export declare type TypedefValueType = TagValue<TypeTag.Typedef>;
@@ -184,9 +181,11 @@ 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 hasNoData(v: AbstractValue, t: TypeTag): boolean;
+export declare function lookupByFullName(state: ProgramStateAnalysis, fullName: string): StateNodeDecl[];
 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 typeFromSingleTypeSpec(state: ProgramStateAnalysis, type: mctree.TypeSpecPart | mctree.ObjectExpression, stack?: ProgramStateStack | undefined): ExactOrUnion;
 export declare function typeFromTypespec(state: ProgramStateAnalysis, ts: mctree.TypeSpecList, stack?: ProgramStateStack | undefined): ExactOrUnion;
 export declare function typeFromLiteral(literal: mctree.Literal): ExactTypes;
 export declare function mcExprFromType(type: ValueTypes): mctree.Expression | null;
@@ -197,6 +196,8 @@ 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 declare function forEachUnionComponent(v: ExactOrUnion, bits: TypeTag, fn: (tag: ExactTypeTags, value: SingleValue | null | undefined) => boolean | void): void;
+export declare function getUnionComponent<T extends ExactTypeTags>(v: ExactOrUnion, tag: T): ExactData<T> | null;
+export declare function setUnionComponent<T extends ExactTypeTags>(v: ExactOrUnion, tag: T, c: ExactData<T>): void;
+export declare function getStateNodeDeclsFromType(state: ProgramStateAnalysis, object: ExactOrUnion): StateNode[];
 export {};

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

@@ -1,3 +1,4 @@
 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;
+export declare function widenType(t: ExactOrUnion): null;

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

@@ -1,3 +1,12 @@
-import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis, StateNode } from "./optimizer-types";
 import { InterpState } from "./type-flow/interp";
-export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode): InterpState | undefined;
+import { ExactOrUnion } from "./type-flow/types";
+export declare const missingNullWorkaround = true;
+export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode, optimizeEquivalencies: boolean): InterpState | undefined;
+export declare function findObjectDeclsByProperty(istate: InterpState, object: ExactOrUnion, next: mctree.DottedMemberExpression): StateNode[] | null;
+export declare function resolveDottedMember(istate: InterpState, object: ExactOrUnion, next: mctree.DottedMemberExpression): {
+    mayThrow: boolean;
+    object: ExactOrUnion;
+    property: import("./type-flow/types").UnionType | import("./type-flow/types").NumberType | import("./type-flow/types").LongType | import("./type-flow/types").FloatType | import("./type-flow/types").DoubleType | import("./type-flow/types").CharType | import("./type-flow/types").StringType | import("./type-flow/types").ArrayType | import("./type-flow/types").DictionaryType | import("./type-flow/types").MethodType | import("./type-flow/types").ModuleType | import("./type-flow/types").FunctionType | import("./type-flow/types").ClassType | import("./type-flow/types").ObjectType | import("./type-flow/types").EnumType | import("./type-flow/types").SymbolType | import("./type-flow/types").TypedefType;
+} | null;

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

@@ -1,3 +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;
+export declare function cleanupUnusedVars(state: ProgramStateOptimizer, node: mctree.BlockStatement | mctree.ForStatement): boolean;

package/build/src/util.d.ts

@@ -7,8 +7,8 @@ export declare function globSome(pattern: string, predicate: (path: string) => b
 }): 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 every<T>(val: T | T[] | null | undefined, fn: (v: T) => boolean): boolean;
+export declare function some<T>(val: T | T[] | null | undefined, fn: (v: T) => boolean): boolean;
 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>;
@@ -21,3 +21,4 @@ export declare function spawnByLine(command: string, args: string[], lineHandler
 export declare function readByLine(file: string, lineHandler: LineHandler): Promise<unknown>;
 export declare function promiseAll<T>(promiseFn: (i: number) => Promise<T> | null, parallelism: number): Promise<T[]>;
 export declare function copyRecursiveAsNeeded(source: string, target: string, filter?: (src: string, tgt: string) => boolean): Promise<void>;
+export declare function popcount(x: number): number;