@markw65/monkeyc-optimizer 1.0.42 → 1.0.44

package/build/src/inliner.d.ts

@@ -1,11 +1,11 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { FunctionStateNode, ProgramStateAnalysis, ProgramStateLive } from "./optimizer-types";
+import { FunctionStateNode, ProgramState, ProgramStateAnalysis } from "./optimizer-types";
 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(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 function diagnostic(state: ProgramState, 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;
 export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;

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

@@ -32,6 +32,7 @@ export declare type BuildConfig = {
     sizeBasedPRE?: boolean | string;
     prettier?: Record<string, unknown>;
     extensionVersion?: string;
+    useLocalOptimizer?: boolean;
 };
 export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
 export declare type StateNodeDecls = {

package/build/src/resources.d.ts

@@ -1,13 +1,12 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { JungleResourceMap } from "./jungles";
+import { ProgramState } from "./optimizer-types";
 import { xmlUtil } from "./sdk-util";
 declare type Visit = (e: xmlUtil.Element, module: string | null, parent: xmlUtil.Element | null) => void;
 declare type Visitor = {
     visit?: Visit;
     error?: (node: xmlUtil.Element, parent: string | null) => void;
-    pre?: (node: xmlUtil.Content) => boolean | null | undefined | void;
-    post?: (node: xmlUtil.Content) => void;
-};
+} & xmlUtil.Visitor;
 export declare function visit_resources(elements: xmlUtil.Content[], parent: xmlUtil.Element | null, v: Visitor | Visit): void;
-export declare function add_resources_to_ast(ast: mctree.Program, resources: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): void;
+export declare function add_resources_to_ast(state: ProgramState | undefined, ast: mctree.Program, resources: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): void;
 export {};

package/build/src/worker-pool.d.ts

@@ -0,0 +1,4 @@
+import type { WorkerTask, WorkerTaskResult } from "./worker-task";
+export declare function startPool(): void;
+export declare function stopPool(): void;
+export declare function runTaskInPool<T extends WorkerTask>(task: T): Promise<WorkerTaskResult<T>>;

package/build/src/worker-task.d.ts

@@ -0,0 +1,29 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+interface BaseNode {
+    type: string;
+    data: unknown;
+}
+interface ParserData extends BaseNode {
+    data: {
+        source: string;
+        options?: Record<string, unknown>;
+    };
+}
+interface JungleParserTask extends ParserData {
+    type: "parseJungle";
+}
+interface MonkeyCParserTask extends ParserData {
+    type: "parseMonkeyC";
+}
+interface XmlParserTask extends ParserData {
+    type: "parseXml";
+}
+export declare type WorkerTask = JungleParserTask | MonkeyCParserTask | XmlParserTask;
+export declare const workerTaskHandlers: {
+    readonly parseJungle: (data: JungleParserTask["data"]) => Assignment[];
+    readonly parseMonkeyC: (data: MonkeyCParserTask["data"]) => mctree.Program;
+    readonly parseXml: (data: XmlParserTask["data"]) => ParserResult;
+};
+export declare type WorkerTaskResult<T> = T extends WorkerTask ? ReturnType<typeof workerTaskHandlers[T["type"]]> : never;
+export declare function performTask<T extends WorkerTask>(task: T): WorkerTaskResult<T>;
+export {};

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

@@ -1,4 +1,3 @@
-import { xmlUtil } from "./sdk-util.js";
 export declare class PeggyError extends Error {
     location: SourceLocation | null | undefined;
     constructor(message: string, location: SourceLocation | null | undefined);
@@ -134,9 +133,17 @@ export declare class Document {
     misc: Array<Misc>;
     source?: string | undefined;
     data?: Record<string, unknown>;
+    private entities;
+    private pentities;
     constructor(prolog: Prolog | null, body: Nodes | Error, misc: Array<Misc>, source?: string | undefined);
-}
-export declare function elementKids(e: Element): xmlUtil.Element[];
+    /**
+     * If all the children are chardata, charref or entityref,
+     * return the resulting string. Otherwise null.
+     */
+    textContent(element: Element): string | null;
+    processRefs(text: string): string;
+}
+export declare function elementKids(e: Element): Element[];
 declare type ElementMatcher = string | ((c: Element) => boolean);
 export declare class Nodes {
     elements: Array<Element>;
@@ -144,11 +151,11 @@ export declare class Nodes {
     length(): number;
     deleteChildren(arg: ElementMatcher): void;
     addChildren(elements: Element[]): void;
-    filter(arg: ElementMatcher): xmlUtil.Nodes;
-    skip(name: string): xmlUtil.Nodes;
-    children(name?: string): xmlUtil.Nodes;
+    filter(arg: ElementMatcher): Nodes;
+    skip(name: string): Nodes;
+    children(name?: string): Nodes;
     text(): string[];
-    attrs(): Record<string, xmlUtil.Attribute | undefined>[];
+    attrs(): Record<string, Attribute | undefined>[];
 }
 export declare function attrString(value: string | AttrStr): AttrStr | {
     readonly type: "attrstr";
@@ -157,4 +164,9 @@ export declare function attrString(value: string | AttrStr): AttrStr | {
 export declare function makeAttribute(name: string | AttrStr, value: string | AttrStr): Attribute;
 export declare function parseXml(content: string, fileName?: string | null): Document;
 export declare function writeXml(doc: Document): string;
+export declare type Visitor = {
+    pre?: (node: Content) => boolean | null | undefined | void;
+    post?: (node: Content) => void;
+};
+export declare function visit_xml(contents: Content[], visitor: Visitor): void;
 export {};

package/build/util.cjs

@@ -7756,7 +7756,7 @@ function globa(pattern, options) {
 }
 function globSome(pattern, predicate, options) {
     return new Promise((resolve, _reject) => {
-        const stream = out.stream(pattern, options || {});
+        const stream = out.stream(pattern.replace(/\\/g, "/"), options || {});
         let result = false;
         const resolver = () => {
             resolve(result);

package/package.json

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

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

@@ -1,324 +0,0 @@
-declare type InclusiveUnionKeys<U> = U extends unknown ? keyof U : never;
-declare type InclusiveUnion<U> = {
-    [K in InclusiveUnionKeys<U>]: U extends any ? K extends keyof U ? U[K] : never : never;
-};
-declare type SubfieldsOfType<T, U> = {
-    [K in keyof T as T[K] extends U ? K : never]: T[K];
-};
-export declare type NodeAll = InclusiveUnion<Node>;
-export declare type NodeSubFields = SubfieldsOfType<NodeAll, Node>;
-export declare type NodeSubArrays = SubfieldsOfType<NodeAll, Node[]>;
-interface BaseNode {
-    type: string;
-    loc?: SourceLocation | null | undefined;
-    start?: number;
-    end?: number;
-    range?: [number, number] | undefined;
-}
-export declare type Node = Identifier | Literal | Program | SwitchCase | CatchClause | VariableDeclarator | EnumStringBody | EnumStringMember | Statement | Expression | Property | Declaration | ImportStatement | AsTypeSpec | TypeSpecList | ClassElement | ClassBody | Comment;
-export interface Comment extends BaseNode {
-    type: "Line" | "Block";
-    value: string;
-}
-interface SourceLocation {
-    source?: string | null | undefined;
-    start: Position;
-    end: Position;
-}
-export interface Position {
-    /** >= 1 */
-    line: number;
-    /** >= 0 */
-    column: number;
-}
-export interface Program extends BaseNode {
-    type: "Program";
-    body: Array<Declaration | ImportStatement>;
-    comments?: Array<Comment> | undefined;
-}
-export interface ModuleDeclaration extends BaseDeclaration {
-    type: "ModuleDeclaration";
-    body: Array<Declaration | ImportStatement>;
-    id: Identifier;
-}
-interface BaseFunction extends BaseNode {
-    params: Array<Identifier | AsExpression>;
-    body: BlockStatement;
-}
-export declare type Statement = ExpressionStatement | BlockStatement | ReturnStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | Declaration;
-interface BaseStatement extends BaseNode {
-}
-export interface BlockStatement extends BaseStatement {
-    type: "BlockStatement";
-    body: Array<Statement>;
-    innerComments?: Array<Comment> | undefined;
-}
-export interface ExpressionStatement extends BaseStatement {
-    type: "ExpressionStatement";
-    expression: Expression;
-}
-export interface IfStatement extends BaseStatement {
-    type: "IfStatement";
-    test: Expression;
-    consequent: Statement;
-    alternate?: Statement | null | undefined;
-}
-export interface BreakStatement extends BaseStatement {
-    type: "BreakStatement";
-}
-export interface ContinueStatement extends BaseStatement {
-    type: "ContinueStatement";
-}
-export interface SwitchStatement extends BaseStatement {
-    type: "SwitchStatement";
-    discriminant: Expression;
-    cases: Array<SwitchCase>;
-}
-export interface ReturnStatement extends BaseStatement {
-    type: "ReturnStatement";
-    argument?: Expression | null | undefined;
-}
-export interface ThrowStatement extends BaseStatement {
-    type: "ThrowStatement";
-    argument: Expression;
-}
-export interface TryStatement extends BaseStatement {
-    type: "TryStatement";
-    block: BlockStatement;
-    handler?: CatchClause | CatchClauses | null | undefined;
-    finalizer?: BlockStatement | null | undefined;
-}
-export interface WhileStatement extends BaseStatement {
-    type: "WhileStatement";
-    test: Expression;
-    body: Statement;
-}
-export interface DoWhileStatement extends BaseStatement {
-    type: "DoWhileStatement";
-    body: Statement;
-    test: Expression;
-}
-export interface ForStatement extends BaseStatement {
-    type: "ForStatement";
-    init?: VariableDeclaration | Expression | null | undefined;
-    test?: Expression | null | undefined;
-    update?: Expression | null | undefined;
-    body: Statement;
-}
-export declare type Declaration = ClassDeclaration | EnumDeclaration | FunctionDeclaration | ModuleDeclaration | TypedefDeclaration | VariableDeclaration;
-interface BaseDeclaration extends BaseStatement {
-    attrs?: AttributeList;
-}
-export interface FunctionDeclaration extends BaseFunction, BaseDeclaration {
-    type: "FunctionDeclaration";
-    id: Identifier;
-    body: BlockStatement;
-    optimizable?: boolean;
-    hasOverride?: boolean;
-}
-export interface VariableDeclaration extends BaseDeclaration {
-    type: "VariableDeclaration";
-    declarations: Array<VariableDeclarator>;
-    kind: "var" | "const";
-}
-export interface VariableDeclarator extends BaseNode {
-    type: "VariableDeclarator";
-    id: Identifier | AsExpression;
-    init?: Expression | null | undefined;
-    kind: "var" | "const";
-}
-declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | Literal | UnaryExpression | UpdateExpression | BinaryExpression | AsExpression | AssignmentExpression | LogicalExpression | MemberExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier;
-export interface BaseExpression extends BaseNode {
-    enumType?: string | Node;
-}
-export interface ThisExpression extends BaseExpression {
-    type: "ThisExpression";
-    text: string;
-}
-export interface ArrayExpression extends BaseExpression {
-    type: "ArrayExpression";
-    elements: Array<Expression>;
-}
-export interface ObjectExpression extends BaseExpression {
-    type: "ObjectExpression";
-    properties: Array<Property>;
-}
-export interface Property extends BaseNode {
-    type: "Property";
-    key: Expression;
-    value: Expression;
-    kind: "init";
-}
-export interface SequenceExpression extends BaseExpression {
-    type: "SequenceExpression";
-    expressions: Array<Expression>;
-}
-interface BaseUnaryExpression extends BaseExpression {
-    type: "UnaryExpression";
-    prefix: true;
-}
-interface TrueUnaryExpression extends BaseUnaryExpression {
-    operator: UnaryOperator;
-    argument: Expression;
-}
-interface SymbolExpression extends BaseUnaryExpression {
-    operator: ":";
-    argument: Identifier;
-}
-export declare type UnaryExpression = TrueUnaryExpression | SymbolExpression;
-export interface BinaryExpression extends BaseExpression {
-    type: "BinaryExpression";
-    operator: BinaryOperator;
-    left: Expression;
-    right: Expression;
-}
-export interface AsExpression extends BaseExpression {
-    type: "BinaryExpression";
-    operator: "as";
-    left: Expression;
-    right: TypeSpecList;
-}
-export interface AssignmentExpression extends BaseExpression {
-    type: "AssignmentExpression";
-    operator: AssignmentOperator;
-    left: Identifier | MemberExpression;
-    right: Expression;
-}
-export interface UpdateExpression extends BaseExpression {
-    type: "UpdateExpression";
-    operator: UpdateOperator;
-    argument: Expression;
-    prefix: boolean;
-}
-export interface LogicalExpression extends BaseExpression {
-    type: "LogicalExpression";
-    operator: LogicalOperator;
-    left: Expression;
-    right: Expression;
-}
-export interface ConditionalExpression extends BaseExpression {
-    type: "ConditionalExpression";
-    test: Expression;
-    alternate: Expression;
-    consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-    callee: Expression;
-    arguments: Array<Expression>;
-}
-export declare type CallExpression = SimpleCallExpression | NewExpression;
-export interface SimpleCallExpression extends BaseCallExpression {
-    type: "CallExpression";
-}
-export interface NewExpression extends BaseCallExpression {
-    type: "NewExpression";
-}
-export interface MemberExpression extends BaseExpression {
-    type: "MemberExpression";
-    object: Expression;
-    property: Expression;
-    computed: boolean;
-}
-export interface SwitchCase extends BaseNode {
-    type: "SwitchCase";
-    test?: Expression | null | undefined;
-    consequent: Array<Statement>;
-}
-export interface CatchClause extends BaseNode {
-    type: "CatchClause";
-    param: Identifier | null;
-    body: BlockStatement;
-}
-export interface CatchClauses extends BaseNode {
-    type: "CatchClauses";
-    catches: CatchClause[];
-}
-export interface Identifier extends BaseNode, BaseExpression {
-    type: "Identifier";
-    name: string;
-}
-export interface Literal extends BaseNode, BaseExpression {
-    type: "Literal";
-    value: string | boolean | number | null;
-    raw?: string | undefined;
-}
-export declare type UnaryOperator = "-" | "+" | "!" | "~" | " as";
-export declare type BinaryOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "has" | "instanceof";
-export declare type LogicalOperator = "||" | "&&";
-export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | "|=" | "^=" | "&=";
-export declare type UpdateOperator = "++" | "--";
-export interface ClassDeclaration extends BaseDeclaration {
-    type: "ClassDeclaration";
-    id: Identifier;
-    superClass?: Expression | null | undefined;
-    body: ClassBody;
-}
-export interface ClassBody extends BaseStatement {
-    type: "ClassBody";
-    body: Array<ClassElement>;
-}
-export interface ClassElement extends BaseStatement {
-    type: "ClassElement";
-    item: Omit<Declaration, "ModuleDeclaration">;
-}
-export interface EnumDeclaration extends BaseDeclaration {
-    type: "EnumDeclaration";
-    id?: Identifier | null;
-    body: EnumStringBody;
-}
-export interface EnumStringBody extends BaseNode {
-    type: "EnumStringBody";
-    members: Array<EnumStringMember | Identifier>;
-    enumType?: string | Node;
-}
-export interface EnumStringMember extends BaseNode {
-    type: "EnumStringMember";
-    id: Identifier;
-    init: Expression;
-    enumType?: string | Node;
-}
-export interface TypedefDeclaration extends BaseDeclaration {
-    type: "TypedefDeclaration";
-    id: Identifier;
-    ts: AsTypeSpec;
-}
-export interface AsTypeSpec extends Omit<UnaryExpression, "operator" | "argument"> {
-    operator: " as";
-    argument: TypeSpecList;
-}
-export interface TypeSpecList extends BaseNode {
-    type: "TypeSpecList";
-    ts: Array<TypeSpecPart>;
-}
-export interface TypeSpecPart extends BaseNode {
-    type: "TypeSpecPart";
-    name: Identifier | MemberExpression;
-    body?: BlockStatement;
-    callspec?: MethodDefinition;
-    generics?: Array<TypeSpecList>;
-}
-export interface MethodDefinition extends BaseNode {
-    type: "MethodDefinition";
-    kind: "method";
-    key: "";
-    params: Array<Identifier | AsExpression>;
-    returnType: AsTypeSpec;
-}
-export declare type AccessSpecifier = "static" | "private" | "protected" | "hidden" | "public";
-export interface AttributeList extends BaseNode {
-    type: "AttributeList";
-    attrs?: Attribute[];
-    access?: AccessSpecifier[];
-}
-declare type Attribute = SymbolExpression | CallExpression;
-export declare type ImportStatement = ImportModule | Using;
-export interface ImportModule extends BaseNode {
-    type: "ImportModule";
-    id: MemberExpression;
-}
-export interface Using extends BaseNode {
-    type: "Using";
-    id: MemberExpression;
-    as: Identifier;
-}
-export {};