@markw65/monkeyc-optimizer 1.0.38 → 1.0.40

package/build/src/api.d.ts

@@ -1,15 +1,24 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
-import { LookupDefinition, ProgramState, ProgramStateLive, ProgramStateNode, StateNode, StateNodeDecl, ProgramStateStack, FunctionInfo, FunctionStateNode } from "./optimizer-types";
-export { visitReferences } from "./visitor";
+import { JungleResourceMap } from "./jungles";
+import { FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl } from "./optimizer-types";
+export { visitorNode, visitReferences } from "./visitor";
 export { traverseAst, hasProperty };
-export declare function getApiMapping(state?: ProgramState, barrelList?: string[]): Promise<ProgramStateNode | null>;
+export declare function parseSdkVersion(version: string | undefined): number;
+export declare function checkCompilerVersion(version: string, sdkVer: number): boolean | undefined;
+export declare function getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>): 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, 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 findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier): ModuleStateNode | {
+    name: string;
+    decls: {
+        parent: StateNode;
+        results: StateNodeDecl[];
+    };
+}[] | null;
 export declare function getApiFunctionInfo(func: FunctionStateNode): FunctionInfo;
 export declare function markInvokeClassMethod(func: FunctionStateNode): void;

package/build/src/inliner.d.ts

@@ -3,8 +3,8 @@ import { FunctionStateNode, ProgramStateAnalysis, ProgramStateLive } from "./opt
 export declare function inlinableSubExpression(expr: mctree.Expression): mctree.SimpleCallExpression | null;
 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[];
-export declare function unused(expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | null;
+export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];
+export declare function unused(state: ProgramStateAnalysis, expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | 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.IfStatement | mctree.AssignmentExpression | mctree.ExpressionStatement | mctree.VariableDeclarator;
 export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): InlineBody | null;

package/build/src/jungles.d.ts

@@ -1,5 +1,6 @@
 import { ManifestXML } from "./manifest";
 import { BuildConfig } from "./optimizer-types.js";
+import { xmlUtil } from "./sdk-util";
 export declare type Target = {
     product: string;
     qualifier: JungleQualifier;
@@ -35,18 +36,21 @@ export declare type JungleQualifier = {
     annotations?: BarrelAnnotations;
     barrelMap?: BarrelMap;
     optBarrels?: OptBarrelMap;
+    resourceMap?: JungleResourceMap;
 };
 declare type JungleInfoBase = {
     jungles: string[];
     manifest: string;
     xml: ManifestXML;
     annotations?: string[];
+    resources: JungleResourceMap;
 };
+export declare type JungleResourceMap = Record<string, xmlUtil.Document | Error>;
 export declare type ResolvedJungle = JungleInfoBase & {
     targets: Target[];
 };
 export declare type ResolvedBarrel = JungleInfoBase & {
     qualifier: JungleQualifier;
 };
-export declare function get_jungle(jungles: string, options: BuildConfig): Promise<ResolvedJungle>;
+export declare function get_jungle(jungles: string, options: BuildConfig, resources?: JungleResourceMap | undefined): Promise<ResolvedJungle>;
 export {};

package/build/src/launch.d.ts

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

package/build/src/manifest.d.ts

@@ -1,65 +1,5 @@
-declare type iqApplication = {
-    $: {
-        id: string;
-        entry: string;
-        launcherIcon: string;
-        minSdkVersion: string;
-        name: string;
-        type: string;
-        version: string;
-    };
-    "iq:products"?: Array<{
-        "iq:product"?: Array<{
-            $: {
-                id: string;
-            };
-        }>;
-    }>;
-    "iq:barrels"?: Array<{
-        "iq:depends"?: Array<{
-            $: {
-                name: string;
-                version: string;
-            };
-        }>;
-    }>;
-    "iq:permissions"?: Array<{
-        "iq:uses-permission"?: Array<{
-            $: {
-                id: string;
-            };
-        }>;
-    }>;
-    "iq:languages"?: Array<{
-        "iq:language"?: Array<string>;
-    }>;
-};
-declare type iqBarrel = {
-    $: {
-        id: string;
-        module: string;
-        version: string;
-    };
-    "iq:products"?: Array<{
-        "iq:product"?: Array<{
-            $: {
-                id: string;
-            };
-        }>;
-    }>;
-    "iq:annotations"?: Array<{
-        "iq:annotation"?: Array<string>;
-    }>;
-};
-export declare type ManifestXML = {
-    "iq:manifest": {
-        $: {
-            "xmlns:iq": string;
-        };
-        "iq:application"?: Array<iqApplication>;
-        "iq:barrel"?: Array<iqBarrel>;
-    };
-};
+import { xmlUtil } from "./sdk-util";
+export declare type ManifestXML = xmlUtil.Document;
 export declare function readManifest(manifest: string): Promise<ManifestXML>;
 export declare function writeManifest(filename: string, xml: ManifestXML): Promise<void>;
 export declare function manifestProducts(manifest: ManifestXML): string[];
@@ -68,4 +8,3 @@ export declare function manifestDropBarrels(manifest: ManifestXML): void;
 export declare function manifestBarrelName(manifestName: string, manifest: ManifestXML): string;
 export declare function manifestAnnotations(manifest: ManifestXML): string[] | undefined;
 export declare function checkManifest(manifest: ManifestXML, products: string[]): Promise<boolean>;
-export {};

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

@@ -1,11 +1,13 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { JungleResourceMap } from "./jungles";
 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 analyze(fnMap: FilesToOptimizeMap, resourcesMap?: Record<string, JungleResourceMap>, config?: BuildConfig): Promise<ProgramStateAnalysis>;
+export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): void;
 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, {
+export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap?: Record<string, JungleResourceMap>, config?: BuildConfig): Promise<Record<string, {
     type: import("./optimizer-types").DiagnosticType;
     loc: {
         start: mctree.Position;

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

@@ -1,6 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ResolvedJungle } from "./jungles";
 export declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
+export declare type LookupRules = "COMPILER1" | "COMPILER2" | "DEFAULT";
+export declare type EnforceStatic = "YES" | "NO";
 export declare type BuildConfig = {
     workspace?: string;
     jungleFiles?: string;
@@ -24,13 +25,12 @@ export declare type BuildConfig = {
     returnCommand?: boolean;
     checkBuildPragmas?: boolean;
     checkInvalidSymbols?: DiagnosticType | "OFF";
+    checkCompilerLookupRules?: DiagnosticType | "OFF";
+    compilerLookupRules?: LookupRules;
+    enforceStatic?: EnforceStatic;
     sizeBasedPRE?: boolean | string;
     prettier?: Record<string, unknown>;
     extensionVersion?: 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 = {
@@ -40,6 +40,12 @@ export declare type ImportUsing = {
     node: mctree.Using | mctree.ImportModule;
     module?: ModuleStateNode | null | undefined;
 };
+export declare enum StateNodeAttributes {
+    PUBLIC = 1,
+    PROTECTED = 2,
+    PRIVATE = 4,
+    STATIC = 8
+}
 interface BaseStateNode {
     type: string;
     node: mctree.Node | null | undefined;
@@ -50,6 +56,7 @@ interface BaseStateNode {
     stack?: ProgramStateStack | undefined;
     usings?: Record<string, ImportUsing>;
     imports?: ImportUsing[];
+    attributes: StateNodeAttributes;
 }
 export interface ProgramStateNode extends BaseStateNode {
     type: "Program";
@@ -87,7 +94,6 @@ export interface FunctionStateNode extends BaseStateNode {
     fullName: string;
     stack?: ProgramStateStack;
     decls?: undefined;
-    isStatic?: boolean;
     info?: FunctionInfo;
     next_info?: FunctionInfo;
 }
@@ -138,6 +144,9 @@ export declare type ProgramState = {
     inType?: number;
     inlining?: true;
     config?: BuildConfig;
+    sdk?: string;
+    sdkVersion?: number;
+    lookupRules?: LookupRules;
     nextExposed?: Record<string, true>;
     exposed?: Record<string, true>;
     usedByName?: Record<string, true>;
@@ -171,7 +180,7 @@ export declare type ProgramState = {
 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 ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
 export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap">;
 export declare type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
 export declare type ExcludeAnnotationsMap = {

package/build/src/optimizer.d.ts

@@ -2,8 +2,8 @@ import { mctree } from "@markw65/prettier-plugin-monkeyc";
 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";
+import { copyRecursiveAsNeeded } from "./util";
 export * from "./optimizer-types";
 export { copyRecursiveAsNeeded, get_jungle, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, };
 export declare const defaultConfig: {
@@ -18,6 +18,19 @@ declare global {
     var lastModifiedSource: number;
 }
 /**
+ *
+ * WARNING WARNING WARNING WARNING WARNING WARNING
+ *
+ * prettier-extension-monkeyc can dynamically import this
+ * function from a local copy of @markw65/monkeyc-optimizer,
+ * rather than using the version that ships with the
+ * extension.
+ *
+ * For this to work, buildOptimizedProject's signature cannot
+ * change (or at least, can only change in a backward compatible
+ * way).
+ *
+ * DON'T CHANGE THIS FUNCTION's SIGNATURE
  *
  * @param {string | null} product
  * @param {BuildConfig} options
@@ -40,13 +53,13 @@ export declare function buildOptimizedProject(product: string | null, options: B
 }>;
 export declare function generateOptimizedProject(options: BuildConfig): Promise<{
     jungleFiles: string | undefined;
-    xml: import("./manifest").ManifestXML;
+    xml: import("./xml-util").Document;
     program: string;
     hasTests: boolean;
     diagnostics?: undefined;
 } | {
     jungleFiles: string;
-    xml: import("./manifest").ManifestXML;
+    xml: import("./xml-util").Document;
     program: string;
     hasTests: boolean;
     diagnostics: Record<string, {

package/build/src/projects.d.ts

@@ -12,10 +12,12 @@ export declare type RemoteProject = string | {
     include?: string;
     sourcePath?: string;
     jungleContent?: string[];
+    garminOptLevel?: number;
 };
 export declare const githubProjects: RemoteProject[];
 export declare function fetchGitProjects(projects: RemoteProject[]): Promise<(string | {
     jungle: string;
     build: boolean | null;
     options: BuildConfig | null;
+    garminOptLevel: number | null;
 })[]>;

package/build/src/resources.d.ts

@@ -0,0 +1,5 @@
+import { Program } from "@markw65/prettier-plugin-monkeyc/build/src/estree-types";
+import { JungleResourceMap } from "./jungles";
+import { xmlUtil } from "./sdk-util";
+export declare function visit_resources(elements: xmlUtil.Element[], parent: string | null, visitor: (e: xmlUtil.Element, module: string | null) => void, error: (e: xmlUtil.Element, parent: string | null) => void): void;
+export declare function add_resources_to_ast(ast: Program, resources: Record<string, JungleResourceMap>): void;

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

@@ -1,4 +1,5 @@
 export { readPrg, SectionKinds } from "./readprg";
+export * as xmlUtil from "./xml-util";
 export declare const isWin: boolean;
 export declare const appSupport: string;
 export declare const connectiq: string;
@@ -15,4 +16,7 @@ export declare type DeviceInfo = {
     };
 };
 export declare function getDeviceInfo(): Promise<DeviceInfo>;
-export declare function getLanguages(): Promise<any>;
+export declare function getLanguages(): Promise<{
+    id: string;
+    name: string;
+}[]>;

package/build/src/visitor.d.ts

@@ -1,3 +1,4 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
+export declare function visitorNode(node: mctree.Node): mctree.Node;
 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/src/xml-util.d.ts

@@ -0,0 +1,140 @@
+export interface Position {
+    /** >= 0 */
+    offset: number;
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+interface BaseNode {
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    start?: number;
+    end?: number;
+    range?: [number, number] | undefined;
+}
+interface CharData extends BaseNode {
+    type: "chardata";
+    value: string;
+}
+interface CharRef extends BaseNode {
+    type: "charref";
+    value: number;
+    base: 10 | 16;
+}
+interface Comment extends BaseNode {
+    type: "comment";
+    value: string;
+}
+interface DocTypeDecl extends BaseNode {
+    type: "doctypedecl";
+    name: string;
+    externalID?: ExternalID;
+    intSubset?: Array<MarkupDecl | PEReference>;
+}
+interface EntityDecl extends BaseNode {
+    type: "entitydecl";
+    name: string;
+    def: XValue;
+    kind: "&" | "%";
+}
+interface XValue extends BaseNode {
+    type: "entityvalue";
+    value?: Array<string | Reference | PEReference>;
+    extid?: System;
+    ndecl?: NData;
+}
+declare type Reference = CharRef | EntityRef;
+declare type PEReference = PERef;
+declare type SystemLiteral = string;
+interface EntityRef extends BaseNode {
+    type: "entityref";
+    name: string;
+}
+interface PERef extends BaseNode {
+    type: "peref";
+    name: string;
+}
+interface NotationDecl extends BaseNode {
+    type: "notationdecl";
+    name: string;
+    id: ExternalID | PublicID;
+}
+interface PublicID extends BaseNode {
+    type: "publicid";
+    value: string;
+}
+interface NData extends BaseNode {
+    type: "ndata";
+    value: string;
+}
+declare type ExternalID = System | Public;
+declare type MarkupDecl = EntityDecl | NotationDecl | PI | Comment;
+interface System extends BaseNode {
+    type: "system";
+    value: SystemLiteral;
+}
+interface Public extends BaseNode {
+    type: "public";
+    value: SystemLiteral;
+    pubid: string;
+}
+declare type Misc = Comment | PI | CharData;
+declare type Content = Element | Reference | CData | Misc;
+export interface CData extends BaseNode {
+    type: "cdata";
+    value: string;
+}
+export interface PI extends BaseNode {
+    type: "pi";
+    name: string;
+    value: string | null;
+}
+export interface Element extends BaseNode {
+    type: "element";
+    name: string;
+    attr: Record<string, string>;
+    children?: Array<Content> | undefined;
+}
+export interface Prolog extends BaseNode {
+    type: "prolog";
+    xmldecl?: XmlDecl;
+    misc1: Misc[];
+    doctypedecl?: DocTypeDecl;
+    misc2: Misc[];
+}
+interface XmlDecl extends BaseNode {
+    type: "xmldecl";
+    version: "1.0";
+    encoding?: string[];
+    standalone?: string[];
+}
+export declare class Document {
+    prolog: Prolog;
+    body: Nodes;
+    misc: Array<Misc>;
+    source?: string | undefined;
+    constructor(prolog: Prolog, body: Nodes, misc: Array<Misc>, source?: string | undefined);
+}
+export declare function elementKids(e: Element): Element[];
+declare type ElementMatcher = string | ((c: Element) => boolean);
+export declare class Nodes {
+    elements: Array<Element>;
+    constructor(elements: Element | Element[]);
+    length(): number;
+    deleteChildren(arg: ElementMatcher): void;
+    addChildren(elements: Element[]): void;
+    filter(arg: ElementMatcher): Nodes;
+    skip(name: string): Nodes;
+    children(name?: string): Nodes;
+    text(): string[];
+    attrs(): Record<string, string>[];
+}
+export declare function parseXml(content: string, fileName?: string | null): Document;
+export declare function writeXml(doc: Document): string;
+export {};