@markw65/monkeyc-optimizer 1.1.7 → 1.1.9

package/build/sdk-util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {SectionKinds,appSupport,connectiq,getDeviceInfo,getLanguages,getSdkPath,isWin,readPrg,xmlUtil});
+0 && (module.exports = {SectionKinds,appSupport,connectiq,getDeviceInfo,getFunctionDocumentation,getLanguages,getSdkPath,isWin,readPrg,xmlUtil});
 /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	// The require scope
@@ -44,6 +44,7 @@ __webpack_require__.d(__webpack_exports__, {
   "appSupport": () => (/* binding */ appSupport),
   "connectiq": () => (/* binding */ connectiq),
   "getDeviceInfo": () => (/* binding */ getDeviceInfo),
+  "getFunctionDocumentation": () => (/* binding */ getFunctionDocumentation),
   "getLanguages": () => (/* binding */ getLanguages),
   "getSdkPath": () => (/* binding */ getSdkPath),
   "isWin": () => (/* binding */ isWin),
@@ -796,6 +797,29 @@ async function getLanguages() {
     })
         .filter((s) => s != null);
 }
+async function getFunctionDocumentation() {
+    const file = external_path_namespaceObject.join(await getSdkPath(), "bin", "api.debug.xml");
+    const data = await promises_namespaceObject.readFile(file);
+    const xml = parseXml(data.toString(), file);
+    if (xml.body instanceof Error) {
+        return null;
+    }
+    const entries = xml.body
+        .children("functions")
+        .children("functionEntry")
+        .elements.map((e) => ({
+        name: e.attr.name?.value.value,
+        parent: e.attr.parent?.value.value,
+        doc: e.children
+            ?.filter((child) => child.type === "element" &&
+            child.name === "documentation" &&
+            child.children != null)
+            .map((doc) => doc.children?.map((c) => c.type === "chardata" || c.type === "cdata" ? c.value : "") || "")
+            .join("") || "",
+    }))
+        .filter((x) => x.name != null && x.parent != null && x.doc !== "");
+    return entries;
+}
 
 var __webpack_export_target__ = exports;
 for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];

package/build/src/api.d.ts

@@ -1,9 +1,10 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
 import { JungleResourceMap } from "./jungles";
-import { ClassStateNode, Diagnostic, DiagnosticType, FunctionInfo, FunctionStateNode, LookupDefinition, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, VariableStateNode } from "./optimizer-types";
+import { ClassStateNode, Diagnostic, DiagnosticType, EnumStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, LookupResult, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode, VariableStateNode } from "./optimizer-types";
 import { visit_resources } from "./resources";
 import { xmlUtil } from "./sdk-util";
+import { TypeMap } from "./type-flow/interp";
 export { visitorNode, visitReferences } from "./visitor";
 export { traverseAst, hasProperty, visit_resources };
 export declare function parseSdkVersion(version: string | undefined): number;
@@ -15,10 +16,25 @@ export declare function isStateNode(node: {
 export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
 declare type DeclKind = "decls" | "type_decls";
 export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function lookupResultContains(a: LookupDefinition[], b: LookupDefinition[]): boolean;
 export declare function isLookupCandidate(node: mctree.MemberExpression): false | mctree.Identifier;
 export declare function lookupNext(state: ProgramStateLive, results: LookupDefinition[], decls: DeclKind, property: mctree.Identifier): LookupDefinition[] | null;
+export declare function lookupWithType(state: ProgramStateAnalysis, node: mctree.Node, typeMap: TypeMap | undefined | null, nonLocal?: boolean, stack?: ProgramStateStack | null): LookupResult;
 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 findNamesInScope(declStack: StateNode[][], pattern: string | RegExp): [StateNodeDecl, {
+    parent: StateNode;
+    depth: number;
+}][];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (ModuleStateNode | FunctionStateNode | ClassStateNode | TypedefStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | EnumStateNode | mctree.EnumStringMember | mctree.Identifier | mctree.AsIdentifier)[];
+export declare function formatAstLongLines(node: mctree.Node): string;
+export declare function createDocumentationMap(functionDocumentation: {
+    name: string;
+    parent: string;
+    doc: string;
+}[]): Promise<Map<string, string>>;
+export declare function makeToyboxLink(result: StateNodeDecl): string | null;
+export declare function lookupByFullName(state: ProgramStateAnalysis, fullName: string): StateNodeDecl[];
 export declare function findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier): ModuleStateNode | {
     name: string;
     decls: {

package/build/src/data-flow.d.ts

@@ -47,7 +47,7 @@ export declare enum FlowKind {
     INSTANCEOF = 6,
     NOTINSTANCE = 7
 }
-interface FlowEventDecl extends BaseEvent {
+export interface FlowEventDecl extends BaseEvent {
     type: "flw";
     node: mctree.BinaryExpression | mctree.UnaryExpression;
     decl?: undefined;
@@ -56,7 +56,7 @@ interface FlowEventDecl extends BaseEvent {
     right_decl: EventDecl;
     right_node?: undefined;
 }
-interface FlowEventNode extends BaseEvent {
+export interface FlowEventNode extends BaseEvent {
     type: "flw";
     node: mctree.BinaryExpression | mctree.UnaryExpression;
     decl?: undefined;
@@ -65,7 +65,7 @@ interface FlowEventNode extends BaseEvent {
     right_decl?: undefined;
     right_node: mctree.Expression;
 }
-interface FlowEventTruthy extends BaseEvent {
+export interface FlowEventTruthy extends BaseEvent {
     type: "flw";
     node: mctree.Node;
     decl?: undefined;
@@ -74,7 +74,7 @@ interface FlowEventTruthy extends BaseEvent {
     right_decl?: undefined;
     right_node?: undefined;
 }
-interface FlowEventInstanceof extends BaseEvent {
+export interface FlowEventInstanceof extends BaseEvent {
     type: "flw";
     node: mctree.InstanceofExpression | mctree.UnaryExpression;
     decl?: undefined;
@@ -106,4 +106,3 @@ export declare class DataflowQueue {
     dequeue(): DataFlowBlock;
     empty(): boolean;
 }
-export {};

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

@@ -62,8 +62,6 @@ interface BaseStateNode {
     decls?: StateNodeDecls | undefined;
     type_decls?: StateNodeDecls | undefined;
     stack?: ProgramStateStack | undefined;
-    usings?: Record<string, ImportUsing>;
-    imports?: ImportUsing[];
     attributes: StateNodeAttributes;
 }
 export interface ProgramStateNode extends BaseStateNode {
@@ -154,8 +152,13 @@ export interface Diagnostic extends DiagnosticBase {
         message: string;
     };
 }
+declare type ProgramStateStackElem = {
+    sn: StateNode;
+    usings?: Record<string, ImportUsing>;
+    imports?: ImportUsing[];
+};
 export declare type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode | TypedefStateNode | VariableStateNode | EnumStateNode;
-export declare type ProgramStateStack = StateNode[];
+export declare type ProgramStateStack = ProgramStateStackElem[];
 export declare type LookupDefinition = {
     parent: StateNode | null;
     results: StateNodeDecl[];
@@ -171,15 +174,16 @@ export declare type ProgramState = {
     rezAst?: mctree.Program;
     manifestXML?: xmlUtil.Document;
     stack?: ProgramStateStack;
+    top?: () => ProgramStateStackElem;
     currentFunction?: FunctionStateNode;
     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 | mctree.Node[];
-    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;
+    lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
+    lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
+    lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
+    lookupNonlocal?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack | null) => LookupResult;
     stackClone?: () => ProgramStateStack;
     traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
     inType?: number;
@@ -216,7 +220,7 @@ export declare type ProgramState = {
 export 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" | "lookupRules">;
+export declare type ProgramStateLive = Finalized<ProgramState, "stack" | "top" | "lookup" | "lookupValue" | "lookupType" | "lookupNonlocal" | "stackClone" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType" | "nextExposed" | "lookupRules">;
 export declare type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions" | "fnMap" | "allDeclarations" | "invokeInfo">;
 export declare type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions" | "usedByName">;
 export declare type ExcludeAnnotationsMap = {

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

@@ -20,3 +20,8 @@ export declare function getLanguages(): Promise<{
     id: string;
     name: string;
 }[]>;
+export declare function getFunctionDocumentation(): Promise<{
+    name: string;
+    parent: string;
+    doc: string;
+}[] | null>;

package/build/src/type-flow/dead-store.d.ts

@@ -1,5 +1,10 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { NodeEquivMap } from "src/type-flow";
 import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
-import { TypeFlowBlock } from "./type-flow-util";
-export declare function findDeadStores(graph: TypeFlowBlock, logThisRun: boolean): Set<mctree.Node>;
+import { TypeFlowBlock, TypeStateKey } from "./type-flow-util";
+export declare function findDeadStores(func: FunctionStateNode, graph: TypeFlowBlock, nodeEquivs: NodeEquivMap | null, logThisRun: boolean): {
+    deadStores: Set<mctree.Node>;
+    locals: Set<TypeStateKey>;
+    localConflicts: Map<TypeStateKey, Set<TypeStateKey>> | null;
+};
 export declare function eliminateDeadStores(state: ProgramStateAnalysis, func: FunctionStateNode, graph: TypeFlowBlock, logThisRun: boolean): boolean;

package/build/src/type-flow/minimize-locals.d.ts

@@ -0,0 +1,2 @@
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+export declare function minimizeLocals(state: ProgramStateAnalysis, func: FunctionStateNode): void;

package/build/src/type-flow/types.d.ts

@@ -26,9 +26,9 @@ export declare const enum TypeTag {
     Typedef = 262144,
     Any = 524287
 }
-export declare function typeTagName(tag: TypeTag): "Object" | "Number" | "Float" | "Double" | "Long" | "String" | "Char" | "Boolean" | "Null" | "Never" | "False" | "True" | "Decimal" | "Numeric" | "Array" | "Dictionary" | "Method" | "Module" | "Function" | "Class" | "Enum" | "Symbol" | "Typedef" | "Any";
+export declare function typeTagName(tag: TypeTag): "Number" | "Float" | "Double" | "Long" | "String" | "Char" | "Boolean" | "Null" | "Never" | "False" | "True" | "Decimal" | "Numeric" | "Array" | "Dictionary" | "Method" | "Module" | "Function" | "Class" | "Object" | "Enum" | "Symbol" | "Typedef" | "Any";
 export declare const LastTypeTag = TypeTag.Typedef;
-export declare const SingleTonTypeTagsConst: number;
+export declare const SingletonTypeTagsConst: number;
 export declare const UnionDataTypeTagsConst: number;
 export declare const ValueTypeTagsConst: number;
 export declare const ObjectLikeTagsConst: number;
@@ -183,7 +183,6 @@ export declare function isUnion(v: AbstractValue): v is UnionType;
 export declare function isSingleton(v: AbstractValue): v is SingletonType;
 export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
 export declare function hasNoData(v: AbstractValue, t: TypeTag): boolean;
-export declare function lookupByFullName(state: ProgramStateAnalysis, fullName: string): StateNodeDecl[];
 export declare function cloneType<T extends ExactOrUnion>(t: T): T;
 export declare function typeFromTypeStateNode(state: ProgramStateAnalysis, sn: StateNodeDecl, classVsObj?: boolean): ExactOrUnion;
 export declare function typeFromTypeStateNodes(state: ProgramStateAnalysis, sns: StateNodeDecl[], classVsObj?: boolean): ExactOrUnion;

package/build/src/type-flow.d.ts

@@ -1,10 +1,23 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { EventDecl } from "./data-flow";
 import { FunctionStateNode, ProgramStateAnalysis, StateNode } from "./optimizer-types";
 import { InterpState } from "./type-flow/interp";
+import { TypeStateKey } from "./type-flow/type-flow-util";
 import { ExactOrUnion } from "./type-flow/types";
 export declare const missingNullWorkaround = true;
+export declare type NodeEquivMap = Map<mctree.Node, {
+    decl: EventDecl;
+    equiv: Array<EventDecl>;
+}>;
 export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode, optimizeEquivalencies: boolean): InterpState | undefined;
-export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): [StateNode[], StateNode[]] | readonly [null, null];
+export declare function buildConflictGraph(state: ProgramStateAnalysis, func: FunctionStateNode): {
+    graph: import("./control-flow").Block<import("./data-flow").RefEvent | import("./data-flow").KillEvent | import("./data-flow").DefEvent | import("./data-flow").ModEvent | import("./data-flow").FlowEventDecl | import("./data-flow").FlowEventNode | import("./data-flow").FlowEventTruthy | import("./data-flow").FlowEventInstanceof | import("./data-flow").ExnEvent>;
+    localConflicts: Map<TypeStateKey, Set<TypeStateKey>> | null;
+    locals: Set<TypeStateKey>;
+    identifiers: Set<string>;
+    logThisRun: boolean;
+} | undefined;
+export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): readonly [null, null] | [StateNode[], StateNode[]];
 export declare function resolveDottedMember(istate: InterpState, object: ExactOrUnion, next: mctree.DottedMemberExpression): {
     mayThrow: boolean;
     object: ExactOrUnion;

package/build/src/visitor.d.ts

@@ -2,4 +2,4 @@ import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 import { TypeMap } from "./type-flow/interp";
 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, includeDefs?: boolean, filter?: ((node: mctree.Node) => boolean) | null, typeMap?: TypeMap | null): void;
+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, includeDefs?: boolean, filter?: ((node: mctree.Node) => boolean) | null, typeMap?: TypeMap | null, findSingleDefinition?: boolean): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -40,7 +40,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.42"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.43"
   },
   "devDependencies": {
     "@types/chai": "^4.3.4",