@markw65/monkeyc-optimizer 1.0.13 → 1.0.16

package/build/sdk-util.cjs

@@ -7215,8 +7215,14 @@ async function getDeviceInfo() {
     }
     return Promise.all(files.map((file) => {
         return promises_namespaceObject.readFile(file).then((data) => {
-            const { deviceId, appTypes, deviceFamily, displayName } = JSON.parse(data.toString());
-            return [deviceId, { appTypes, deviceFamily, displayName }];
+            const { deviceId, appTypes, deviceFamily, displayName, partNumbers } = JSON.parse(data.toString());
+            const languages = Object.fromEntries(partNumbers
+                .map((part) => part.languages.map((lang) => [lang.code, true]))
+                .flat(1));
+            return [
+                deviceId,
+                { appTypes, deviceFamily, displayName, languages },
+            ];
         });
     })).then((info) => {
         return Object.fromEntries(info);

package/build/src/inliner.d.ts

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, args: mctree.Node[]): boolean | undefined;
+export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression): any;
+export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;

package/build/src/optimizer.d.ts

@@ -34,67 +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;
-        shouldExclude?: (node: any) => any;
+        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;
         lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
+        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;
+        inType?: boolean;
         exposed?: {
             [key: string]: true;
         };
@@ -120,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">;
-    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;
@@ -174,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/sdk-util.d.ts

@@ -2,7 +2,7 @@ export declare const isWin: boolean;
 export declare const appSupport: string;
 export declare const connectiq: string;
 export declare function getSdkPath(): Promise<string>;
-export declare function getDeviceInfo(): Promise<{
+export declare type DeviceInfo = {
     [key: string]: {
         appTypes: {
             memoryLimit: number;
@@ -10,6 +10,8 @@ export declare function getDeviceInfo(): Promise<{
         }[];
         deviceFamily: string;
         displayName: string;
+        languages: Record<string, true>;
     };
-}>;
+};
+export declare function getDeviceInfo(): Promise<DeviceInfo>;
 export declare function getLanguages(): Promise<any>;

package/build/util.cjs

@@ -1303,6 +1303,8 @@ function setopts (self, pattern, options) {
   // Note that they are not supported in Glob itself anyway.
   options.nonegate = true
   options.nocomment = true
+  // always treat \ in patterns as escapes, not path separators
+  options.allowWindowsEscape = false
 
   self.minimatch = new Minimatch(pattern, options)
   self.options = self.minimatch.options
@@ -1778,7 +1780,10 @@ Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
   var read
   if (prefix === null)
     read = '.'
-  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+  else if (isAbsolute(prefix) ||
+      isAbsolute(pattern.map(function (p) {
+        return typeof p === 'string' ? p : '[*]'
+      }).join('/'))) {
     if (!prefix || !isAbsolute(prefix))
       prefix = '/' + prefix
     read = prefix
@@ -2278,7 +2283,7 @@ function GlobSync (pattern, options) {
 }
 
 GlobSync.prototype._finish = function () {
-  assert(this instanceof GlobSync)
+  assert.ok(this instanceof GlobSync)
   if (this.realpath) {
     var self = this
     this.matches.forEach(function (matchset, index) {
@@ -2302,7 +2307,7 @@ GlobSync.prototype._finish = function () {
 
 
 GlobSync.prototype._process = function (pattern, index, inGlobStar) {
-  assert(this instanceof GlobSync)
+  assert.ok(this instanceof GlobSync)
 
   // Get the first [n] parts of pattern that are all strings.
   var n = 0
@@ -2339,7 +2344,10 @@ GlobSync.prototype._process = function (pattern, index, inGlobStar) {
   var read
   if (prefix === null)
     read = '.'
-  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+  else if (isAbsolute(prefix) ||
+      isAbsolute(pattern.map(function (p) {
+        return typeof p === 'string' ? p : '[*]'
+      }).join('/'))) {
     if (!prefix || !isAbsolute(prefix))
       prefix = '/' + prefix
     read = prefix

package/package.json

@@ -1,21 +1,28 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.13",
+  "version": "1.0.16",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
   "exports": {
-    ".": "./build/optimizer.cjs",
-    "./*.js": "./build/*.cjs"
+    ".": {
+      "types": "./build/src/optimizer.d.ts",
+      "default": "./build/optimizer.cjs"
+    },
+    "./*.js": {
+      "types": "./build/src/*.d.ts",
+      "default": "./build/*.cjs"
+    }
   },
   "scripts": {
     "watch": "webpack --mode development --watch",
     "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",
@@ -27,7 +34,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.20"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.21"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",