@markw65/monkeyc-optimizer 1.1.2 → 1.1.4

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");
@@ -255,6 +255,9 @@ function withLoc(node, start, end) {
         if (!node.end)
             node.end = start.end;
         node.loc = { ...(node.loc || start.loc), start: start.loc.start };
+        if (end === start && start.origins) {
+            node.origins = start.origins;
+        }
     }
     if (end === false) {
         if (node.loc) {
@@ -270,6 +273,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)
@@ -284,17 +290,17 @@ function cloneDeep(node) {
     return withLocDeep(node, null);
 }
 function getNodeValue(node) {
-    if (node.type == "BinaryExpression" &&
-        node.operator == "as" &&
-        node.right.type == "TypeSpecList" &&
-        node.right.ts.length == 1 &&
-        typeof node.right.ts[0] == "string") {
+    if (node.type === "BinaryExpression" &&
+        node.operator === "as" &&
+        node.right.type === "TypeSpecList" &&
+        node.right.ts.length === 1 &&
+        typeof node.right.ts[0] === "string") {
         // this is a cast we inserted to retain the type of an enum
         // any arithmetic on it will revert to "Number", or "Long",
         // so just ignore it.
         return getNodeValue(node.left);
     }
-    if (node.type != "Literal") {
+    if (node.type !== "Literal") {
         return [null, null];
     }
     if (node.value === null) {
@@ -384,13 +390,13 @@ function makeScopedName(dotted, l) {
 function getLiteralNode(node) {
     if (node == null)
         return null;
-    if (node.type == "Literal")
+    if (node.type === "Literal")
         return node;
-    if (node.type == "BinaryExpression" && node.operator == "as") {
+    if (node.type === "BinaryExpression" && node.operator === "as") {
         return getLiteralNode(node.left) && node;
     }
-    if (node.type == "UnaryExpression") {
-        if (node.argument.type != "Literal")
+    if (node.type === "UnaryExpression") {
+        if (node.argument.type !== "Literal")
             return null;
         switch (node.operator) {
             case "-": {
@@ -692,7 +698,7 @@ function visit_xml(contents, visitor) {
         if (visitor.pre && visitor.pre(c) === false) {
             return;
         }
-        if (c.type == "element" && c.children) {
+        if (c.type === "element" && c.children) {
             visit_xml(c.children, visitor);
         }
         if (visitor.post)
@@ -733,13 +739,13 @@ async function readPrg(path) {
 
 
 
-const isWin = process.platform == "win32";
+const isWin = process.platform === "win32";
 const appSupport = isWin
     ? `${process.env.APPDATA}`.replace(/\\/g, "/")
-    : process.platform == "linux"
+    : process.platform === "linux"
         ? `${process.env.HOME}/.config`
         : `${process.env.HOME}/Library/Application Support`;
-const connectiq = process.platform == "linux"
+const connectiq = process.platform === "linux"
     ? `${process.env.HOME}/.Garmin/ConnectIQ`
     : `${appSupport}/Garmin/ConnectIQ`;
 function getSdkPath() {

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,6 @@ 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 diagnosticHelper(diagnostics: Record<string, Diagnostic[]>, node: mctree.Node, message: string | null, type: DiagnosticType | undefined, extra: Diagnostic["extra"] | undefined, uniqueLocs: boolean): 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>;
@@ -108,7 +109,7 @@ export interface FunctionStateNode extends BaseStateNode {
 export interface BlockStateNode extends BaseStateNode {
     type: "BlockStatement";
     name: undefined;
-    fullName: undefined;
+    fullName: string;
     node: mctree.BlockStatement | mctree.ForStatement;
     stack?: undefined;
 }
@@ -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,15 @@ 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[]>;
+    inlineDiagnostics?: 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

@@ -4,6 +4,7 @@ import { launchSimulator, simulateProgram } from "./launch";
 import { manifestProducts } from "./manifest";
 import { BuildConfig, FilesToOptimizeMap, ProgramStateAnalysis } from "./optimizer-types";
 import { xmlUtil } from "./sdk-util";
+import { TypeMap } from "./type-flow/interp";
 import { copyRecursiveAsNeeded } from "./util";
 export * from "./optimizer-types";
 export { copyRecursiveAsNeeded, get_jungle, JungleBuildDependencies, JungleError, JungleResourceMap, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, };
@@ -43,14 +44,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 +57,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;
@@ -85,6 +72,7 @@ export declare type Analysis = {
     fnMap: RequiredNonNull<FilesToOptimizeMap>;
     paths: string[];
     state: ProgramStateAnalysis;
+    typeMap?: TypeMap | null | undefined;
 };
 export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, manifestXML: xmlUtil.Document, options: BuildConfig): Promise<Analysis | PreAnalysis>;
 /**

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;