@markw65/monkeyc-optimizer 1.0.29 → 1.0.32

package/build/src/api.d.ts

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

package/build/src/ast.d.ts

@@ -6,4 +6,5 @@ export declare function mayThrow(node: mctree.Node): boolean;
 export declare function hasProperty<T extends null extends T ? unknown : undefined extends T ? unknown : never>(obj: T, prop: string): obj is NonNullable<T>;
 export declare function hasProperty<T>(obj: T, prop: string): boolean;
 export declare function withLoc<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined): T;
-export declare function withLocDeep<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined): T;
+export declare function withLocDeep<T extends mctree.Node>(node: T, start: mctree.Node | null, end?: mctree.Node | undefined, inplace?: boolean): T;
+export declare function cloneDeep<T extends mctree.Node>(node: T): T;

package/build/src/build.d.ts

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

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

@@ -1,4 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ProgramStateAnalysis, FunctionStateNode } from "./optimizer-types";
 export declare type BaseEvent = {
     type: string;
     mayThrow: boolean;

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

@@ -0,0 +1,12 @@
+import { VariableStateNode, FunctionStateNode, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
+export declare function cloneSet<T>(ae: Set<T>): Set<T>;
+export declare function mergeSet<T>(a: Set<T>, b: Set<T>): void;
+export declare function recordModifiedDecl(func: FunctionStateNode, decl: VariableStateNode): null;
+export declare function recordModifiedDecls(func: FunctionStateNode, lookupDefs: LookupDefinition[]): void;
+export declare function recordModifiedName(func: FunctionStateNode, name: string): void;
+export declare function recordModifiedUnknown(func: FunctionStateNode): void;
+export declare function recordCalledFunc(func: FunctionStateNode, callee: FunctionStateNode): null;
+export declare function recordCalledFuncs(func: FunctionStateNode, callees: FunctionStateNode[]): void;
+export declare function functionMayModify(state: ProgramStateAnalysis, func: FunctionStateNode, decl: VariableStateNode): boolean;
+export declare function findCallees(lookupDefs: LookupDefinition[]): FunctionStateNode[] | null;
+export declare function findCalleesForNew(lookupDefs: LookupDefinition[]): FunctionStateNode[];

package/build/src/inliner.d.ts

@@ -1,4 +1,5 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis, ProgramStateLive } from "./optimizer-types";
 export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): boolean;
 declare type InlineBody = mctree.BlockStatement | mctree.ExpressionStatement["expression"];
 export declare function unused(expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];

package/build/src/jungles.d.ts

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

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

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

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

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

package/build/src/optimizer.d.ts

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

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

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

package/build/src/pre.d.ts

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

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

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

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

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

package/build/src/visitor.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.29",
+  "version": "1.0.32",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -20,11 +20,11 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-optimized && npm run test-remote",
+    "test": "npm run test-optimized && npm run test-unopt && npm run test-remote",
     "test-remote": "node ./test/test.js --product=pick-one --github",
-    "test-optimized": "node test/test.js --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
-    "test-unopt": "node test/test.js --skipOptimization --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
-    "test-garmin-opt": "node test/test.js --skipOptimization --garminOptLevel=2 --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
+    "test-optimized": "node test/test.js --typeCheckLevel Strict --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
+    "test-unopt": "node test/test.js --typeCheckLevel Strict --skipOptimization --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
+    "test-garmin-opt": "node test/test.js --typeCheckLevel Strict --skipOptimization --garminOptLevel=2 --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle",
     "eslint": "npx eslint ."
   },
   "files": [
@@ -37,7 +37,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.32"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.33"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",