@markw65/monkeyc-optimizer 1.0.45 → 1.1.0

package/build/sdk-util.cjs

@@ -237,8 +237,6 @@ function mayThrow(node) {
     switch (node.type) {
         case "BinaryExpression":
         case "CallExpression":
-        case "ConditionalExpression":
-        case "LogicalExpression":
         case "NewExpression":
         case "ThrowStatement":
         case "UnaryExpression":
@@ -383,6 +381,28 @@ function makeScopedName(dotted, l) {
         throw new Error("Failed to make a ScopedName");
     return result;
 }
+function getLiteralNode(node) {
+    if (node == null)
+        return null;
+    if (node.type == "Literal")
+        return node;
+    if (node.type == "BinaryExpression" && node.operator == "as") {
+        return getLiteralNode(node.left) && node;
+    }
+    if (node.type == "UnaryExpression") {
+        if (node.argument.type != "Literal")
+            return null;
+        switch (node.operator) {
+            case "-": {
+                const [arg, type] = getNodeValue(node.argument);
+                if (type === "Number" || type === "Long") {
+                    return { ...arg, value: -arg.value, raw: `-${arg.raw}` };
+                }
+            }
+        }
+    }
+    return null;
+}
 
 ;// CONCATENATED MODULE: ./src/xml-util.ts
 

package/build/src/api.d.ts

@@ -1,7 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
 import { JungleResourceMap } from "./jungles";
-import { FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, VariableStateNode } from "./optimizer-types";
+import { ClassStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, VariableStateNode } from "./optimizer-types";
 import { visit_resources } from "./resources";
 import { xmlUtil } from "./sdk-util";
 export { visitorNode, visitReferences } from "./visitor";
@@ -22,6 +22,8 @@ export declare function findUsingForNode(state: ProgramStateLive, stack: Program
         results: StateNodeDecl[];
     };
 }[] | null;
-export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo | false;
-export declare function markInvokeClassMethod(func: FunctionStateNode): void;
+export declare function getApiFunctionInfo(state: ProgramState, func: FunctionStateNode): FunctionInfo | false;
+export declare function markInvokeClassMethod(state: ProgramStateAnalysis, func: FunctionStateNode): void;
 export declare function isLocal(v: VariableStateNode): boolean;
+export declare function diagnostic(state: ProgramState, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
+export declare function getSuperClasses(klass: ClassStateNode): Set<ClassStateNode> | null;

package/build/src/ast.d.ts

@@ -55,4 +55,5 @@ export declare function makeIdentifier(name: string, loc?: mctree.SourceLocation
 };
 export declare function makeMemberExpression(object: mctree.ScopedName, property: mctree.Identifier): mctree.DottedName;
 export declare function makeScopedName(dotted: string, l?: mctree.SourceLocation): mctree.ScopedName;
+export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
 export {};

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

@@ -13,7 +13,7 @@ export declare type Block<T extends EventConstraint<T>> = {
     exsucc?: Block<T>;
     events?: T[];
 };
-export declare function buildReducedGraph<T extends EventConstraint<T>>(state: ProgramStateAnalysis, func: FunctionStateNode, notice: (node: mctree.Node, stmt: mctree.Node, mayThrow: boolean) => T | null): Block<T>;
+export declare function buildReducedGraph<T extends EventConstraint<T>>(state: ProgramStateAnalysis, func: FunctionStateNode, notice: (node: mctree.Node, stmt: mctree.Node, mayThrow: boolean | 1) => T | null): Block<T>;
 export declare function postOrderTraverse<T extends EventConstraint<T>>(head: Block<T>, visitor: (block: Block<T>) => void): void;
 export declare function preOrderTraverse<T extends EventConstraint<T>>(head: Block<T>, visitor: (block: Block<T>) => void): void;
 export declare function getPostOrder<T extends EventConstraint<T>>(head: Block<T>): Block<T>[];

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

@@ -31,7 +31,7 @@ export interface DataFlowBlock extends Block<Event> {
 }
 export declare function declFullName(decl: EventDecl): string | undefined;
 export declare function declName(decl: EventDecl): string | undefined;
-export declare function unhandledExpression(node: never): void;
+export declare function unhandledType(node: never): never;
 export declare function buildDataFlowGraph(state: ProgramStateAnalysis, func: FunctionStateNode, wantsLiteral: (literal: mctree.Literal) => boolean, trackInsertionPoints: boolean, wantsAllRefs: boolean): {
     identifiers: Set<string>;
     graph: Block<RefEvent | DefEvent | ModEvent | ExnEvent>;

package/build/src/inliner.d.ts

@@ -1,11 +1,10 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { FunctionStateNode, ProgramState, ProgramStateAnalysis } from "./optimizer-types";
+import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
 export declare function inlinableSubExpression(expr: mctree.Expression): mctree.SimpleCallExpression | null;
 export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): boolean;
 declare type InlineBody = mctree.BlockStatement | mctree.ExpressionStatement["expression"];
 export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];
 export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | null;
-export declare function diagnostic(state: ProgramState, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
 export declare type InlineContext = mctree.ReturnStatement | mctree.IfStatement | mctree.AssignmentExpression | mctree.ExpressionStatement | mctree.VariableDeclarator;
 export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): InlineBody | null;
 export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;

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

@@ -4,10 +4,9 @@ import { BuildConfig, FilesToOptimizeMap, LookupDefinition, ProgramStateAnalysis
 import { xmlUtil } from "./sdk-util";
 export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
 export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
-export declare function analyze(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document, config: BuildConfig): Promise<ProgramStateAnalysis>;
+export declare function analyze(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document | undefined, config: BuildConfig): Promise<ProgramStateAnalysis>;
 export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): void;
 export declare function getLiteralFromDecls(lookupDefns: LookupDefinition[]): mctree.Literal | mctree.AsExpression | null;
-export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
 export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap: Record<string, JungleResourceMap>, manifestXML: xmlUtil.Document, config: BuildConfig): Promise<Record<string, {
     type: import("./optimizer-types").DiagnosticType;
     loc: {

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

@@ -1,6 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { EnumStringMember } from "@markw65/prettier-plugin-monkeyc/build/estree-types";
 import { xmlUtil } from "./sdk-util";
+import { ExactOrUnion } from "./type-flow/types";
 export declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
 export declare type LookupRules = "COMPILER1" | "COMPILER2" | "DEFAULT";
 export declare type EnforceStatic = "YES" | "NO";
@@ -34,6 +35,9 @@ export declare type BuildConfig = {
     prettier?: Record<string, unknown>;
     extensionVersion?: string;
     useLocalOptimizer?: boolean;
+    propagateTypes?: boolean;
+    trustDeclaredTypes?: boolean;
+    checkTypes?: DiagnosticType | "OFF";
 };
 export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier;
 export declare type StateNodeDecls = {
@@ -81,6 +85,7 @@ export interface ClassStateNode extends BaseStateNode {
     fullName: string;
     superClass?: ClassStateNode[] | true;
     hasInvoke?: boolean;
+    superClasses?: Set<ClassStateNode>;
 }
 export declare type FunctionInfo = {
     modifiedDecls: Set<VariableStateNode>;
@@ -112,6 +117,9 @@ export interface TypedefStateNode extends BaseStateNode {
     node: mctree.TypedefDeclaration;
     name: string;
     fullName: string;
+    isExpanding?: true;
+    isRecursive?: true;
+    resolvedType?: ExactOrUnion;
 }
 export interface VariableStateNode extends BaseStateNode {
     type: "VariableDeclarator";
@@ -138,6 +146,7 @@ export declare type LookupResult = [string, LookupDefinition[]] | [null, null] |
 export declare type ProgramState = {
     allFunctions?: Record<string, FunctionStateNode[]>;
     allClasses?: ClassStateNode[];
+    invokeInfo?: FunctionInfo;
     fnMap?: FilesToOptimizeMap;
     rezAst?: mctree.Program;
     manifestXML?: xmlUtil.Document;
@@ -190,11 +199,11 @@ export declare type ProgramState = {
     }[]>;
     enumMap?: Map<EnumStringMember, EnumStateNode>;
 };
-declare type Finalized<T, Keys extends keyof T> = T & {
+export declare type Finalized<T, Keys extends keyof T> = T & {
     [key in Keys]-?: NonNullable<T[key]>;
 };
 export declare type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
-export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap">;
+export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap" | "invokeInfo">;
 export declare type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
 export declare type ExcludeAnnotationsMap = {
     [key: string]: boolean;

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

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

package/build/src/worker-pool.d.ts

@@ -1,4 +1,4 @@
 import type { WorkerTask, WorkerTaskResult } from "./worker-task";
-export declare function startPool(): void;
+export declare function startPool(parallelism?: number): void;
 export declare function stopPool(): void;
 export declare function runTaskInPool<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;

package/build/src/worker-task.d.ts

@@ -1,29 +1,60 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { BuildConfig } from "./optimizer";
 interface BaseNode {
     type: string;
     data: unknown;
 }
-interface ParserData extends BaseNode {
+interface BuildOptimizedProject extends BaseNode {
+    type: "buildOptimizedProject";
     data: {
-        source: string;
-        options?: Record<string, unknown>;
+        product: string | null;
+        options: BuildConfig;
     };
 }
-interface JungleParserTask extends ParserData {
-    type: "parseJungle";
-}
-interface MonkeyCParserTask extends ParserData {
-    type: "parseMonkeyC";
-}
-interface XmlParserTask extends ParserData {
-    type: "parseXml";
+interface GenerateOptimizedProject extends BaseNode {
+    type: "generateOptimizedProject";
+    data: {
+        options: BuildConfig;
+    };
 }
-export declare type WorkerTask = JungleParserTask | MonkeyCParserTask | XmlParserTask;
+export declare type WorkerTask = BuildOptimizedProject | GenerateOptimizedProject;
 export declare const workerTaskHandlers: {
-    readonly parseJungle: (data: JungleParserTask["data"]) => Assignment[];
-    readonly parseMonkeyC: (data: MonkeyCParserTask["data"]) => mctree.Program;
-    readonly parseXml: (data: XmlParserTask["data"]) => ParserResult;
+    readonly buildOptimizedProject: (data: BuildOptimizedProject["data"]) => Promise<{
+        exe: string;
+        args: string[];
+        program: string;
+        product: string | null;
+        hasTests: boolean;
+        diagnostics: Record<string, {
+            type: import("./optimizer-types").DiagnosticType;
+            loc: {
+                start: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+                end: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+            };
+            message: string;
+        }[]> | undefined;
+    }>;
+    readonly generateOptimizedProject: (data: GenerateOptimizedProject["data"]) => Promise<{
+        jungleFiles: string | undefined;
+        xml: import("./xml-util").Document;
+        program: string;
+        hasTests: boolean;
+        diagnostics?: undefined;
+    } | {
+        jungleFiles: string;
+        xml: import("./xml-util").Document;
+        program: string;
+        hasTests: boolean;
+        diagnostics: Record<string, {
+            type: import("./optimizer-types").DiagnosticType;
+            loc: {
+                start: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+                end: import("@markw65/prettier-plugin-monkeyc/build/estree-types").Position;
+            };
+            message: string;
+        }[]>;
+    }>;
 };
-export declare type WorkerTaskResult<T> = T extends WorkerTask ? ReturnType<typeof workerTaskHandlers[T["type"]]> : never;
-export declare function performTask<T extends WorkerTask>(task: T): WorkerTaskResult<T>;
+declare type RemovePromise<T> = T extends Promise<infer U> ? U : T;
+export declare type WorkerTaskResult<T> = T extends WorkerTask ? RemovePromise<ReturnType<typeof workerTaskHandlers[T["type"]]>> : never;
+export declare function performTask<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;
 export {};

package/build/src/worker-thread.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.45",
+  "version": "1.1.0",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -21,7 +21,8 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-optimized && npm run test-unopt && npm run test-remote && npm run test-remote-tests",
+    "test": "npm run test-mocha && npm run test-optimized && npm run test-unopt && npm run test-remote && npm run test-remote-tests",
+    "test-mocha": "npx mocha --timeout 999999 build/mocha.cjs",
     "test-remote": "node ./test/test.js --product=pick-one --github",
     "test-remote-tests": "node ./test/test.js --product=pick-one --run-tests --github",
     "test-optimized": "node test/test.js --typeCheckLevel Strict --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
@@ -42,14 +43,18 @@
     "@markw65/prettier-plugin-monkeyc": "^1.0.41"
   },
   "devDependencies": {
+    "@types/chai": "^4.3.4",
     "@types/glob": "^8.0.0",
+    "@types/mocha": "^10.0.1",
     "@types/prettier": "^2.6.1",
     "@types/priorityqueuejs": "^1.0.1",
     "@typescript-eslint/eslint-plugin": "^5.28.0",
     "@typescript-eslint/parser": "^5.28.0",
+    "chai": "^4.3.7",
     "eslint": "^8.12.0",
     "extract-zip": "^2.0.1",
     "fast-glob": "^3.2.12",
+    "mocha": "^10.2.0",
     "peggy": "^2.0.1",
     "prettier": "^2.6.2",
     "prettier-plugin-pegjs": "https://github.com/markw65/prettier-plugin-pegjs/releases/download/v0.5.2/prettier-plugin-pegjs-0.5.2.tgz",

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

@@ -1,4 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ExactOrUnion } from "./mc-types";
-export declare function evaluateBinaryTypes(op: mctree.BinaryOperator | "instanceof", left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;
-export declare function evaluateLogicalTypes(op: mctree.LogicalOperator, left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;

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

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

package/build/src/interp.d.ts

@@ -1,23 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ExactOrUnion } from "./type-flow/types";
-import { FunctionStateNode, ProgramStateAnalysis } from "./optimizer-types";
-export declare type TypeMap = Map<mctree.Node, ExactOrUnion>;
-export declare type InterpStackElem = {
-    value: ExactOrUnion;
-    embeddedEffects: boolean;
-    node: mctree.Expression | mctree.TypeSpecList | mctree.InstanceOfCase;
-};
-export declare type InterpState = {
-    state: ProgramStateAnalysis;
-    stack: InterpStackElem[];
-    typeMap?: TypeMap;
-    func?: FunctionStateNode;
-    pre?: (node: mctree.Node) => mctree.Node | null | void;
-    post?: (node: mctree.Node) => mctree.Node | null | void;
-};
-export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
-export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;
-export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
-export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
-export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
-export declare function roundToFloat(value: number): number;

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

@@ -1,166 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl } 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
-}
-export declare enum TypeTag {
-    Never = 0,
-    Null = 1,
-    False = 2,
-    True = 4,
-    Boolean = 6,
-    Number = 8,
-    Long = 16,
-    Float = 32,
-    Double = 64,
-    Numeric = 120,
-    Char = 128,
-    String = 256,
-    Array = 512,
-    Dictionary = 1024,
-    Module = 2048,
-    Function = 4096,
-    Class = 8192,
-    Object = 16384,
-    Enum = 32768,
-    Symbol = 65536,
-    Any = 131071
-}
-declare type ExactTypeTags = TypeTag.Null | TypeTag.False | TypeTag.True | TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double | TypeTag.Char | TypeTag.String | TypeTag.Array | TypeTag.Dictionary | TypeTag.Module | TypeTag.Function | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Function | TypeTag.Symbol;
-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;
-declare type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : T & {
-    value: NonNullable<T["value"]>;
-} : never;
-export declare type ValueTypes = WithValue<ExactTypes>;
-export declare type ExtendedTypes = ExactTypes | NeverType | AnyType;
-export interface NeverType extends AbstractValue {
-    type: 0;
-    value?: undefined;
-}
-export interface NullType extends AbstractValue {
-    type: TypeTag.Null;
-    value?: undefined;
-}
-export interface FalseType extends AbstractValue {
-    type: TypeTag.False;
-    value?: undefined;
-}
-export interface TrueType extends AbstractValue {
-    type: TypeTag.True;
-    value?: undefined;
-}
-export interface NumberType extends AbstractValue {
-    type: TypeTag.Number;
-    value?: number | undefined;
-}
-export interface LongType extends AbstractValue {
-    type: TypeTag.Long;
-    value?: bigint | undefined;
-}
-export interface FloatType extends AbstractValue {
-    type: TypeTag.Float;
-    value?: number | undefined;
-}
-export interface DoubleType extends AbstractValue {
-    type: TypeTag.Double;
-    value?: number | undefined;
-}
-export interface CharType extends AbstractValue {
-    type: TypeTag.Char;
-    value?: string | undefined;
-}
-export interface StringType extends AbstractValue {
-    type: TypeTag.String;
-    value?: string | undefined;
-}
-export interface ArrayType extends AbstractValue {
-    type: TypeTag.Array;
-    value?: ExactOrUnion | undefined;
-}
-export interface DictionaryType extends AbstractValue {
-    type: TypeTag.Dictionary;
-    value?: {
-        key: ExactOrUnion;
-        value: ExactOrUnion;
-    } | undefined;
-}
-export interface ModuleType extends AbstractValue {
-    type: TypeTag.Module;
-    value?: ModuleStateNode | ModuleStateNode[] | undefined;
-}
-export interface FunctionType extends AbstractValue {
-    type: TypeTag.Function;
-    value?: FunctionStateNode | FunctionStateNode[] | undefined;
-}
-export interface ClassType extends AbstractValue {
-    type: TypeTag.Class;
-    value?: ClassStateNode | ClassStateNode[] | undefined;
-}
-export interface ObjectType extends AbstractValue {
-    type: TypeTag.Object;
-    value?: {
-        klass: ClassType;
-        obj?: Record<string, ExactOrUnion>;
-    } | undefined;
-}
-export interface EnumType extends AbstractValue {
-    type: TypeTag.Enum;
-    value?: {
-        enum: EnumStateNode;
-        value?: ExactOrUnion | undefined;
-    } | undefined;
-}
-export interface SymbolType extends AbstractValue {
-    type: TypeTag.Symbol;
-    value?: string | undefined;
-}
-export interface AnyType extends AbstractValue {
-    type: -1;
-    value?: undefined;
-}
-export declare type SingletonType = NullType | FalseType | TrueType;
-export interface UnionType extends AbstractValue {
-    value?: undefined;
-}
-export declare type ExactOrUnion = UnionType | ExactTypes;
-export declare function isExact(v: AbstractValue): v is ExactTypes;
-export declare function isUnion(v: AbstractValue): v is UnionType;
-export declare function isSingleton(v: AbstractValue): v is SingletonType;
-export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
-export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
-export declare function cloneType<T extends ExactOrUnion>(t: T): T;
-export declare function typeFromTypeStateNode(state: ProgramStateAnalysis, sn: StateNodeDecl, classVsObj?: boolean): ExactOrUnion;
-export declare function 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;
-export declare function castType(type: ExactOrUnion, target: UnionTypeTags): ExactOrUnion;
-export declare const TruthyTypes: number;
-export declare function mustBeTrue(arg: ExactOrUnion): boolean;
-export declare function mustBeFalse(arg: ExactOrUnion): boolean;
-export declare function display(type: ExactOrUnion): string;
-export {};