@markw65/monkeyc-optimizer 1.0.19 → 1.0.22

package/build/src/api.d.ts

@@ -1,9 +1,12 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-export declare function getApiMapping(state?: ProgramState): Promise<ProgramStateNode | null>;
+export { visitReferences } from "./visitor";
+export declare function getApiMapping(state?: ProgramState, barrelList?: string[]): Promise<ProgramStateNode | null>;
 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 isStateNode(node: StateNodeDecl): node is StateNode;
-export declare function variableDeclarationName(node: mctree.TypedIdentifier): string;
+export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
+export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
 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 | mctree.Node[]): false | void | null | mctree.Node | mctree.Node[];
 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;

package/build/src/inliner.d.ts

@@ -1,13 +1,9 @@
 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, call: mctree.CallExpression, context: InlineContext | null): boolean;
 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 diagnostic(state: ProgramStateLive, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
 export declare type InlineContext = mctree.ReturnStatement | mctree.AssignmentExpression | mctree.ExpressionStatement;
 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/launch.d.ts

@@ -1,2 +1,3 @@
+import { LineHandler } from "./util";
 export declare function launchSimulator(): Promise<void>;
-export declare function simulateProgram(prg: string, device: string, test?: boolean): Promise<void>;
+export declare function simulateProgram(prg: string, device: string, test?: boolean, logger?: LineHandler | LineHandler[]): Promise<void>;

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

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

package/build/src/optimizer.d.ts

@@ -13,6 +13,7 @@ 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;
@@ -35,6 +36,7 @@ declare global {
         ignoredSourcePaths?: string;
         returnCommand?: boolean;
         checkBuildPragmas?: boolean;
+        checkInvalidSymbols?: DiagnosticType | "OFF";
         _cache?: {
             barrels?: Record<string, ResolvedJungle>;
             barrelMap?: Record<string, Record<string, ResolvedJungle>>;
@@ -44,6 +46,10 @@ declare global {
     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;
@@ -52,10 +58,12 @@ declare global {
         decls?: StateNodeDecls | undefined;
         type_decls?: StateNodeDecls | undefined;
         stack?: ProgramStateStack | undefined;
+        usings?: Record<string, ImportUsing>;
+        imports?: ImportUsing[];
     }
     interface ProgramStateNode extends BaseStateNode {
         type: "Program";
-        node: null | undefined;
+        node: mctree.Program | undefined;
         name: "$";
         fullName: "$";
         stack?: undefined;
@@ -80,6 +88,7 @@ declare global {
         fullName: string;
         stack?: ProgramStateStack;
         decls?: undefined;
+        isStatic?: boolean;
     }
     interface BlockStateNode extends BaseStateNode {
         type: "BlockStatement";
@@ -103,6 +112,11 @@ declare global {
     }
     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[];
@@ -112,16 +126,20 @@ declare global {
         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) => [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];
+        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]: unknown[];
+            [key: string]: mctree.FunctionDeclaration[];
         };
         localsStack?: {
             node?: mctree.Node;
@@ -139,7 +157,7 @@ declare global {
             [key: string]: mctree.Literal;
         };
         diagnostics?: Record<string, {
-            type: "ERROR" | "WARNING" | "INFO";
+            type: DiagnosticType;
             loc: {
                 start: mctree.Position;
                 end: mctree.Position;
@@ -150,7 +168,7 @@ declare global {
     type Finalized<T, Keys extends keyof T> = T & {
         [key in Keys]-?: NonNullable<T[key]>;
     };
-    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType">;
+    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 = {
@@ -181,7 +199,7 @@ export declare function buildOptimizedProject(product: string | null, options: B
     product: string | null;
     hasTests: boolean | undefined;
     diagnostics: Record<string, {
-        type: "ERROR" | "WARNING" | "INFO";
+        type: DiagnosticType;
         loc: {
             start: mctree.Position;
             end: mctree.Position;
@@ -201,7 +219,7 @@ export declare function generateOptimizedProject(options: BuildConfig): Promise<
     program: string;
     hasTests: boolean;
     diagnostics: Record<string, {
-        type: "ERROR" | "WARNING" | "INFO";
+        type: DiagnosticType;
         loc: {
             start: mctree.Position;
             end: mctree.Position;

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

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

package/build/src/util.d.ts

@@ -2,12 +2,12 @@ import * as glob from "glob";
 export declare function globa(pattern: string, options?: glob.IOptions): Promise<Array<string>>;
 export declare function last_modified(inputs: string[]): Promise<number>;
 export declare function first_modified(inputs: string[]): Promise<number>;
-export declare function pushUnique<T>(arr: T[], value: T): void;
-declare type LineHandler = (line: string) => void;
+export declare function pushUnique<T, U extends T>(arr: T[], value: U): void;
+export declare function sameArrays<T>(a1: T[], a2: T[], check: (a: T, b: T) => boolean): boolean;
+export declare type LineHandler = (line: string) => void;
 export declare function spawnByLine(command: string, args: string[], lineHandlers: LineHandler | LineHandler[], options?: {
     [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 copyRecursiveAsNeeded(source: string, target: string, filter?: (src: string, tgt: string) => boolean): Promise<void>;
-export {};

package/build/src/visitor.d.ts

@@ -0,0 +1,2 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+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/build/util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,first_modified,globa,last_modified,promiseAll,pushUnique,readByLine,spawnByLine});
+0 && (module.exports = {copyRecursiveAsNeeded,first_modified,globa,last_modified,promiseAll,pushUnique,readByLine,sameArrays,spawnByLine});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -4005,6 +4005,7 @@ __webpack_require__.d(__webpack_exports__, {
   "promiseAll": () => (/* binding */ promiseAll),
   "pushUnique": () => (/* binding */ pushUnique),
   "readByLine": () => (/* binding */ readByLine),
+  "sameArrays": () => (/* binding */ sameArrays),
   "spawnByLine": () => (/* binding */ spawnByLine)
 });
 
@@ -4065,6 +4066,9 @@ function pushUnique(arr, value) {
         return;
     arr.push(value);
 }
+function sameArrays(a1, a2, check) {
+    return a1.length === a2.length && a1.every((e, i) => check(e, a2[i]));
+}
 // return a promise that will process the output of command
 // line-by-line via lineHandlers.
 function spawnByLine(command, args, lineHandlers, options) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.19",
+  "version": "1.0.22",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -34,7 +34,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.22"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.26"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",