@markw65/monkeyc-optimizer 1.0.31 → 1.0.34

package/README.md

@@ -378,3 +378,29 @@ Bug Fixes
   - Collect info about what each function may modify and call
   - Better analysis of inline function bodies
   - Update the StateNodeDecls when renaming locals
+
+### 1.0.32
+
+- Bug fixes
+  - Fixup the tests to run unoptimized again, and add running unoptimized to the standard test run
+  - Fix PRE to not merge Numbers and Floats (ie 1 is not the same thing as 1.0), and add a test
+
+### 1.0.33
+
+- New features
+
+  - Tagging a function with (:keep) will prevent the optimizer from removing it, even if it appears to be unused.
+
+- Bug fixes
+  - Fix PRE to not merge values with different types. ie Number, Long, Float and Double literals should all be treated separately, even when the compare the same.
+
+### 1.0.34
+
+- Bug fixes
+
+  - Fix parser to allow white space to separate attributes, in addition to comma
+  - Fix optimizer to respect prettier options when formatting the optimized code
+
+- Testing
+  - rewrite test harness in typescript
+  - fix up tests to work with compiler2 again, and also with compiler2 at -O0

package/build/api.cjs

@@ -281,6 +281,7 @@ const promises_namespaceObject = require("fs/promises");
 ;// CONCATENATED MODULE: external "prettier"
 const external_prettier_namespaceObject = require("prettier");
 ;// CONCATENATED MODULE: ./src/ast.ts
+
 /*
  * This ensures that mctreeTypeInfo has every key of MCTreeTypeInfo,
  * and that the corresponding arrays contain every element of the
@@ -482,6 +483,44 @@ function ast_withLocDeep(node, start, end, inplace) {
 function ast_cloneDeep(node) {
     return ast_withLocDeep(node, null);
 }
+function ast_getNodeValue(node) {
+    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 ast_getNodeValue(node.left);
+    }
+    if (node.type != "Literal") {
+        return [null, null];
+    }
+    if (node.value === null) {
+        return [node, "Null"];
+    }
+    const type = typeof node.value;
+    if (type === "number") {
+        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
+        if (match) {
+            return match[2] === "l" || match[2] === "L"
+                ? [node, "Long"]
+                : [node, "Number"];
+        }
+        return [node, node.raw.endsWith("d") ? "Double" : "Float"];
+    }
+    if (type === "bigint") {
+        return [node, "Long"];
+    }
+    if (type === "string") {
+        return [node, "String"];
+    }
+    if (type === "boolean") {
+        return [node, "Boolean"];
+    }
+    throw new Error(`Literal has unknown type '${type}'`);
+}
 
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
@@ -2164,10 +2203,15 @@ function buildPREGraph(state, func) {
                     break;
                 case "Literal":
                     if (refCost(node) > LocalRefCost) {
-                        let decl = literals.get(node.value);
+                        const result = getNodeValue(node);
+                        const key = result[1] +
+                            (result[0].value === null
+                                ? ""
+                                : "-" + result[0].value.toString());
+                        let decl = literals.get(key);
                         if (!decl) {
                             decl = node;
-                            literals.set(node.value, decl);
+                            literals.set(key, decl);
                         }
                         return {
                             type: "ref",
@@ -3367,7 +3411,7 @@ function getLiteralNode(node) {
             return null;
         switch (node.operator) {
             case "-": {
-                const [arg, type] = getNodeValue(node.argument);
+                const [arg, type] = ast_getNodeValue(node.argument);
                 if (type === "Number" || type === "Long") {
                     return replacementLiteral(arg, -arg.value, type);
                 }
@@ -3376,44 +3420,6 @@ function getLiteralNode(node) {
     }
     return 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") {
-        // 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") {
-        return [null, null];
-    }
-    if (node.value === null) {
-        return [node, "Null"];
-    }
-    const type = typeof node.value;
-    if (type === "number") {
-        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
-        if (match) {
-            return match[2] === "l" || match[2] === "L"
-                ? [node, "Long"]
-                : [node, "Number"];
-        }
-        return [node, node.raw.endsWith("d") ? "Double" : "Float"];
-    }
-    if (type === "bigint") {
-        return [node, "Long"];
-    }
-    if (type === "string") {
-        return [node, "String"];
-    }
-    if (type === "boolean") {
-        return [node, "Boolean"];
-    }
-    throw new Error(`Literal has unknown type '${type}'`);
-}
 function fullTypeName(state, tsp) {
     if (typeof tsp.name === "string") {
         return tsp.name;
@@ -4246,6 +4252,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             case "FunctionDeclaration":
                 if (!maybeCalled(node)) {
+                    if (node.attrs &&
+                        node.attrs.attributes &&
+                        node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" && attr.argument.name === "keep")) {
+                        break;
+                    }
                     return false;
                 }
                 break;
@@ -5048,7 +5059,7 @@ function api_collectNamespaces(ast, stateIn) {
     }
     return state.stack[0];
 }
-function api_formatAst(node, monkeyCSource = null) {
+function api_formatAst(node, monkeyCSource = null, options = null) {
     /*
      * The estree printer sometimes looks at the parent node without
      * checking that there *is* a parent node (eg it assumes all
@@ -5076,6 +5087,7 @@ function api_formatAst(node, monkeyCSource = null) {
     // looking for in the source.
     const source = (monkeyCSource || "") + "\n" + (0,prettier_plugin_monkeyc_namespaceObject.serializeMonkeyC)(node);
     return external_prettier_namespaceObject.format(source, {
+        ...(options || {}),
         parser: "monkeyc-json",
         plugins: [(prettier_plugin_monkeyc_default())],
         endOfLine: "lf",

package/build/optimizer.cjs

@@ -10024,6 +10024,8 @@ const external_crypto_namespaceObject = require("crypto");
 const promises_namespaceObject = require("fs/promises");
 // EXTERNAL MODULE: external "path"
 var external_path_ = __webpack_require__(1423);
+;// CONCATENATED MODULE: external "prettier"
+const external_prettier_namespaceObject = require("prettier");
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
 ;// CONCATENATED MODULE: external "./sdk-util.cjs"
@@ -10977,6 +10979,7 @@ function simulateProgram(prg, device, test = false, logger) {
 }
 
 ;// CONCATENATED MODULE: ./src/ast.ts
+
 /*
  * This ensures that mctreeTypeInfo has every key of MCTreeTypeInfo,
  * and that the corresponding arrays contain every element of the
@@ -11178,6 +11181,44 @@ function withLocDeep(node, start, end, inplace) {
 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") {
+        // 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") {
+        return [null, null];
+    }
+    if (node.value === null) {
+        return [node, "Null"];
+    }
+    const type = typeof node.value;
+    if (type === "number") {
+        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
+        if (match) {
+            return match[2] === "l" || match[2] === "L"
+                ? [node, "Long"]
+                : [node, "Number"];
+        }
+        return [node, node.raw.endsWith("d") ? "Double" : "Float"];
+    }
+    if (type === "bigint") {
+        return [node, "Long"];
+    }
+    if (type === "string") {
+        return [node, "String"];
+    }
+    if (type === "boolean") {
+        return [node, "Boolean"];
+    }
+    throw new Error(`Literal has unknown type '${type}'`);
+}
 
 ;// CONCATENATED MODULE: ./src/function-info.ts
 
@@ -12856,10 +12897,15 @@ function buildPREGraph(state, func) {
                     break;
                 case "Literal":
                     if (refCost(node) > LocalRefCost) {
-                        let decl = literals.get(node.value);
+                        const result = getNodeValue(node);
+                        const key = result[1] +
+                            (result[0].value === null
+                                ? ""
+                                : "-" + result[0].value.toString());
+                        let decl = literals.get(key);
                         if (!decl) {
                             decl = node;
-                            literals.set(node.value, decl);
+                            literals.set(key, decl);
                         }
                         return {
                             type: "ref",
@@ -14067,44 +14113,6 @@ function getLiteralNode(node) {
     }
     return 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") {
-        // 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") {
-        return [null, null];
-    }
-    if (node.value === null) {
-        return [node, "Null"];
-    }
-    const type = typeof node.value;
-    if (type === "number") {
-        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
-        if (match) {
-            return match[2] === "l" || match[2] === "L"
-                ? [node, "Long"]
-                : [node, "Number"];
-        }
-        return [node, node.raw.endsWith("d") ? "Double" : "Float"];
-    }
-    if (type === "bigint") {
-        return [node, "Long"];
-    }
-    if (type === "string") {
-        return [node, "String"];
-    }
-    if (type === "boolean") {
-        return [node, "Boolean"];
-    }
-    throw new Error(`Literal has unknown type '${type}'`);
-}
 function fullTypeName(state, tsp) {
     if (typeof tsp.name === "string") {
         return tsp.name;
@@ -14937,6 +14945,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             case "FunctionDeclaration":
                 if (!maybeCalled(node)) {
+                    if (node.attrs &&
+                        node.attrs.attributes &&
+                        node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" && attr.argument.name === "keep")) {
+                        break;
+                    }
                     return false;
                 }
                 break;
@@ -15036,6 +15049,7 @@ function optimizeCall(state, node, context) {
 
 
 
+
 function relative_path_no_dotdot(relative) {
     return relative.replace(/^(\.\.[\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
 }
@@ -15458,28 +15472,35 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1657670997056 < opt_time) {
+        if (source_time < opt_time && 1659827507288 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
     await promises_namespaceObject.rm(output, { recursive: true, force: true });
     await promises_namespaceObject.mkdir(output, { recursive: true });
     const diagnostics = await optimizeMonkeyC(fnMap, Object.keys(buildConfig.barrelMap || {}), config);
-    return Promise.all(Object.values(fnMap).map(async (info) => {
-        const name = info.output;
-        const dir = external_path_.dirname(name);
-        await promises_namespaceObject.mkdir(dir, { recursive: true });
-        const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(info.ast, info.monkeyCSource);
-        await promises_namespaceObject.writeFile(name, opt_source);
-        return info.hasTests;
-    })).then((results) => {
-        const hasTests = results.some((v) => v);
-        return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
-            hasTests,
-            diagnostics,
-            ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
-        }))
-            .then(() => ({ hasTests, diagnostics }));
+    return external_prettier_namespaceObject.resolveConfig(config.workspace, {
+        useCache: false,
+        editorconfig: true,
+    }).then((prettierConfig) => {
+        const options = { ...prettierConfig, ...(config.prettier || {}) };
+        return Promise.all(Object.values(fnMap).map(async (info) => {
+            const name = info.output;
+            const dir = external_path_.dirname(name);
+            await promises_namespaceObject.mkdir(dir, { recursive: true });
+            options.filepath = name;
+            const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(info.ast, info.monkeyCSource, options);
+            await promises_namespaceObject.writeFile(name, opt_source);
+            return info.hasTests;
+        })).then((results) => {
+            const hasTests = results.some((v) => v);
+            return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
+                hasTests,
+                diagnostics,
+                ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
+            }))
+                .then(() => ({ hasTests, diagnostics }));
+        });
     });
 }
 async function getProjectAnalysis(targets, analysis, options) {

package/build/sdk-util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {appSupport,connectiq,getDeviceInfo,getLanguages,getSdkPath,isWin});
+0 && (module.exports = {SectionKinds,appSupport,connectiq,getDeviceInfo,getLanguages,getSdkPath,isWin,readPrg});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -7171,12 +7171,14 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  "SectionKinds": () => (/* reexport */ SectionKinds),
   "appSupport": () => (/* binding */ appSupport),
   "connectiq": () => (/* binding */ connectiq),
   "getDeviceInfo": () => (/* binding */ getDeviceInfo),
   "getLanguages": () => (/* binding */ getLanguages),
   "getSdkPath": () => (/* binding */ getSdkPath),
-  "isWin": () => (/* binding */ isWin)
+  "isWin": () => (/* binding */ isWin),
+  "readPrg": () => (/* reexport */ readPrg)
 });
 
 ;// CONCATENATED MODULE: external "fs/promises"
@@ -7187,11 +7189,38 @@ const external_path_namespaceObject = require("path");
 var xml2js = __webpack_require__(5055);
 ;// CONCATENATED MODULE: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
+;// CONCATENATED MODULE: ./src/readprg.ts
+
+var SectionKinds;
+(function (SectionKinds) {
+    SectionKinds[SectionKinds["TEXT"] = -1059145026] = "TEXT";
+    SectionKinds[SectionKinds["DATA"] = -629491010] = "DATA";
+})(SectionKinds || (SectionKinds = {}));
+async function readPrg(path) {
+    const data = await promises_namespaceObject.readFile(path);
+    const view = new DataView(data.buffer);
+    const sections = {};
+    let offset = 0;
+    while (view.byteLength - offset > 8) {
+        const type = view.getInt32(offset);
+        offset += 4;
+        const length = view.getInt32(offset);
+        offset += 4;
+        if (length > view.byteLength - offset) {
+            throw new Error(`Invalid length for section ${type}`);
+        }
+        sections[type] = length;
+        offset += length;
+    }
+    return sections;
+}
+
 ;// CONCATENATED MODULE: ./src/sdk-util.ts
 
 
 
 
+
 const isWin = process.platform == "win32";
 const appSupport = isWin
     ? `${process.env.APPDATA}`.replace(/\\/g, "/")

package/build/src/api.d.ts

@@ -9,7 +9,7 @@ export declare function variableDeclarationName(node: mctree.TypedIdentifier | m
 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 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, isType: boolean): StateNodeDecl[] | null;
 export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo;
 export declare function markInvokeClassMethod(func: FunctionStateNode): void;

package/build/src/ast.d.ts

@@ -8,3 +8,22 @@ 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, inplace?: boolean): T;
 export declare function cloneDeep<T extends mctree.Node>(node: T): T;
+interface NumberLiteral extends mctree.Literal {
+    value: number;
+}
+interface LongLiteral extends mctree.Literal {
+    value: number | bigint;
+}
+interface StringLiteral extends mctree.Literal {
+    value: string;
+}
+interface BooleanLiteral extends mctree.Literal {
+    value: boolean;
+}
+interface NullLiteral extends mctree.Literal {
+    value: null;
+}
+declare type LiteralValues = [NumberLiteral, "Number" | "Float" | "Double"] | [LongLiteral, "Long"] | [StringLiteral, "String"] | [BooleanLiteral, "Boolean"] | [NullLiteral, "Null"];
+export declare function getNodeValue(node: mctree.Literal): LiteralValues;
+export declare function getNodeValue(node: mctree.Node): LiteralValues | [null, null];
+export {};

package/build/src/driver.d.ts

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

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

@@ -6,7 +6,7 @@ export declare function analyze(fnMap: FilesToOptimizeMap, barrelList?: string[]
 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: "ERROR" | "WARNING" | "INFO";
+    type: import("./optimizer-types").DiagnosticType;
     loc: {
         start: mctree.Position;
         end: mctree.Position;

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

@@ -1,6 +1,6 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { ResolvedJungle } from "./jungles";
-declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
+export declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
 export declare type BuildConfig = {
     workspace?: string;
     jungleFiles?: string;
@@ -25,6 +25,7 @@ export declare type BuildConfig = {
     checkBuildPragmas?: boolean;
     checkInvalidSymbols?: DiagnosticType | "OFF";
     sizeBasedPRE?: boolean | string;
+    prettier?: Record<string, unknown>;
     _cache?: {
         barrels?: Record<string, ResolvedJungle>;
         barrelMap?: Record<string, Record<string, ResolvedJungle>>;

package/build/src/optimizer.d.ts

@@ -30,7 +30,7 @@ export declare function buildOptimizedProject(product: string | null, options: B
     product: string | null;
     hasTests: boolean;
     diagnostics: Record<string, {
-        type: "ERROR" | "WARNING" | "INFO";
+        type: import("./optimizer-types").DiagnosticType;
         loc: {
             start: mctree.Position;
             end: mctree.Position;
@@ -50,7 +50,7 @@ export declare function generateOptimizedProject(options: BuildConfig): Promise<
     program: string;
     hasTests: boolean;
     diagnostics: Record<string, {
-        type: "ERROR" | "WARNING" | "INFO";
+        type: import("./optimizer-types").DiagnosticType;
         loc: {
             start: mctree.Position;
             end: mctree.Position;

package/build/src/projects.d.ts

@@ -0,0 +1,21 @@
+import { BuildConfig } from "./optimizer-types";
+export declare type RemoteProject = string | {
+    root: string;
+    options?: BuildConfig;
+    rename?: {
+        from: string;
+        to: string;
+    }[];
+    build?: boolean;
+    comment?: string;
+    exclude?: string;
+    include?: string;
+    sourcePath?: string;
+    jungleContent?: string[];
+};
+export declare const githubProjects: RemoteProject[];
+export declare function fetchGitProjects(projects: RemoteProject[]): Promise<(string | {
+    jungle: string;
+    build: boolean | null;
+    options: BuildConfig | null;
+})[]>;

package/build/src/readprg.d.ts

@@ -0,0 +1,5 @@
+export declare enum SectionKinds {
+    TEXT = -1059145026,
+    DATA = -629491010
+}
+export declare function readPrg(path: string): Promise<Record<number, number>>;

package/build/src/sdk-util.d.ts

@@ -1,3 +1,4 @@
+export { readPrg, SectionKinds } from "./readprg";
 export declare const isWin: boolean;
 export declare const appSupport: string;
 export declare const connectiq: string;

package/build/src/util.d.ts

@@ -9,5 +9,5 @@ export declare function spawnByLine(command: string, args: string[], lineHandler
     [key: string]: unknown;
 }): Promise<void>;
 export declare function readByLine(file: string, lineHandler: LineHandler): Promise<unknown>;
-export declare function promiseAll<T>(promiseFn: (i: number) => Promise<T>, parallelism: number): Promise<T[]>;
+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>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.31",
+  "version": "1.0.34",
   "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.33"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.34"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",