@markw65/monkeyc-optimizer 1.0.14 → 1.0.17

package/build/sdk-util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {isWin,appSupport,connectiq,getSdkPath,getDeviceInfo,getLanguages});
+0 && (module.exports = {appSupport,connectiq,getDeviceInfo,getLanguages,getSdkPath,isWin});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 

package/build/src/api.d.ts

@@ -5,5 +5,5 @@ export declare function hasProperty<T>(obj: T, prop: string): boolean;
 export declare function isStateNode(node: StateNodeDecl): node is StateNode;
 export declare function variableDeclarationName(node: mctree.TypedIdentifier): string;
 export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
-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): false | void | null | mctree.Node;
+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 formatAst(node: mctree.Node, monkeyCSource?: string | null): string;

package/build/src/inliner.d.ts

@@ -0,0 +1,13 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare enum InlineStatus {
+    Never = 0,
+    AsExpression = 1,
+    AsStatement = 2
+}
+export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, args: mctree.Node[]): InlineStatus;
+declare type InlineBody = mctree.BlockStatement | mctree.ExpressionStatement["expression"];
+export declare function unused(expression: mctree.ExpressionStatement["expression"]): mctree.ExpressionStatement[];
+export declare function unused(expression: mctree.ExpressionStatement["expression"], top: true): mctree.ExpressionStatement[] | null;
+export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, inlineStatus: InlineStatus): InlineBody | null;
+export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;
+export {};

package/build/src/optimizer.d.ts

@@ -34,68 +34,89 @@ declare global {
         ignoredAnnotations?: string;
         ignoredSourcePaths?: string;
         returnCommand?: boolean;
+        checkBuildPragmas?: boolean;
         _cache?: {
             barrels?: Record<string, ResolvedJungle>;
             barrelMap?: Record<string, Record<string, ResolvedJungle>>;
         };
     };
-    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration | mctree.TypedefDeclaration | mctree.VariableDeclarator;
+    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
     type StateNodeDecls = {
         [key: string]: StateNodeDecl[];
     };
-    type ProgramStateNode = {
+    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;
+    }
+    interface ProgramStateNode extends BaseStateNode {
         type: "Program";
         node: null | undefined;
         name: "$";
         fullName: "$";
-        decls?: StateNodeDecls;
-        stack?: null | undefined;
-    };
-    type ModuleStateNode = {
+        stack?: undefined;
+    }
+    interface ModuleStateNode extends BaseStateNode {
         type: "ModuleDeclaration";
+        node: mctree.ModuleDeclaration;
         name: string;
         fullName: string;
-        node: mctree.ModuleDeclaration;
-        stack?: ProgramStateStack;
-        decls?: StateNodeDecls;
-    };
-    type ClassStateNode = {
+    }
+    interface ClassStateNode extends BaseStateNode {
         type: "ClassDeclaration";
+        node: mctree.ClassDeclaration;
         name: string;
         fullName: string;
-        node: mctree.ClassDeclaration;
-        decls?: StateNodeDecls;
-        stack?: ProgramStateStack;
-        superClass: ClassStateNode[] | true;
-    };
-    type FunctionStateNode = {
+        superClass?: ClassStateNode[] | true;
+    }
+    interface FunctionStateNode extends BaseStateNode {
         type: "FunctionDeclaration";
+        node: mctree.FunctionDeclaration;
         name: string;
         fullName: string;
-        node: mctree.FunctionDeclaration;
         stack?: ProgramStateStack;
         decls?: undefined;
-    };
-    type BlockStateNode = {
+    }
+    interface BlockStateNode extends BaseStateNode {
         type: "BlockStatement";
-        name?: null | undefined;
-        fullName?: null | undefined;
+        name: undefined;
+        fullName: undefined;
         node: mctree.BlockStatement;
-        decls?: StateNodeDecls;
-        stack?: null | undefined;
-    };
-    type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode;
+        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[];
     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;
+        post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node | mctree.Node[];
         lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
-        traverse?: (node: mctree.Node) => void | null | false | mctree.Node;
+        lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
+        lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
+        traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
+        inType?: boolean;
         exposed?: {
             [key: string]: true;
         };
@@ -121,8 +142,8 @@ declare global {
     type Finalized<T, Keys extends keyof T> = T & {
         [key in Keys]-?: NonNullable<T[key]>;
     };
-    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "traverse" | "index" | "constants" | "removeNodeComments">;
-    export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions">;
+    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "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;
@@ -175,7 +196,7 @@ declare type RequiredNonNull<T> = {
 export declare type Analysis = {
     fnMap: RequiredNonNull<FilesToOptimizeMap>;
     paths: string[];
-    state: ProgramState;
+    state: ProgramStateAnalysis;
 };
 export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, options: BuildConfig): Promise<Analysis | PreAnalysis>;
 /**

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

@@ -0,0 +1,2 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function pragmaChecker(ast: mctree.Program): void;

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

@@ -0,0 +1 @@
+export declare function renameVariable(state: ProgramStateAnalysis, locals: NonNullable<ProgramStateAnalysis["localsStack"]>[number], declName: string): string | null;

package/build/util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {globa,last_modified,first_modified,pushUnique,spawnByLine,readByLine,promiseAll,copyRecursiveAsNeeded});
+0 && (module.exports = {copyRecursiveAsNeeded,first_modified,globa,last_modified,promiseAll,pushUnique,readByLine,spawnByLine});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.14",
+  "version": "1.0.17",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -20,8 +20,9 @@
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
-    "test": "npm run test-remote",
-    "test-remote": "node ./test/test.js --product=pick-one --github"
+    "test": "npm run test-inline && npm run test-remote",
+    "test-remote": "node ./test/test.js --product=pick-one --github",
+    "test-inline": "node test/test.js --run-tests --product=fenix5 --product=fr235 --jungle $(pwd)/test/OptimizerTests/monkey.jungle"
   },
   "files": [
     "build/optimizer.cjs",