@markw65/monkeyc-optimizer 1.0.39 → 1.0.40

package/build/optimizer.cjs

@@ -3977,7 +3977,7 @@ async function resolve_literals(qualifier, default_source, deviceInfo) {
     qualifier.annotations = annotations;
     return qualifier;
 }
-async function read_resource_files(targets) {
+async function read_resource_files(targets, cache) {
     const resourceGroups = {};
     const resources = {};
     await Promise.all(targets.map(async (p) => {
@@ -3993,8 +3993,16 @@ async function read_resource_files(targets) {
                 .flat()
                 .filter((file) => file.endsWith(".xml"))
                 .map((file) => {
-                if ((0,external_api_cjs_namespaceObject.hasProperty)(resources, file)) {
-                    return { path: file, resources: resources[file] };
+                if (!cache.resources) {
+                    cache.resources = {};
+                }
+                else if ((0,external_api_cjs_namespaceObject.hasProperty)(cache.resources, file)) {
+                    const rez = cache.resources[file];
+                    resources[file] = rez;
+                    return {
+                        path: file,
+                        resources: rez,
+                    };
                 }
                 return promises_namespaceObject.readFile(file)
                     .then((data) => external_sdk_util_cjs_namespaceObject.xmlUtil.parseXml(data.toString(), file))
@@ -4002,7 +4010,7 @@ async function read_resource_files(targets) {
                     ? e
                     : new Error("An unknown error occurred"))
                     .then((rez) => {
-                    resources[file] = rez;
+                    cache.resources[file] = resources[file] = rez;
                     return {
                         path: file,
                         resources: rez,
@@ -4408,13 +4416,13 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options, cac
         }
     });
     await promise;
-    const { resourceGroups, resources } = await read_resource_files(targets);
+    const { resourceGroups, resources } = await read_resource_files(targets, cache);
     await find_build_instructions(targets, resourceGroups);
     return { manifest, targets, xml, annotations, jungles, resources };
 }
-async function get_jungle(jungles, options) {
+async function get_jungle(jungles, options, resources) {
     options = options || {};
-    const cache = {};
+    const cache = resources ? { resources: { ...resources } } : {};
     const result = await get_jungle_and_barrels(jungles, null, options, cache);
     identify_optimizer_groups(result.targets, options);
     return result;
@@ -4460,8 +4468,12 @@ function checkIfSimulatorRunningOn(port) {
 }
 function simulateProgram(prg, device, test = false, logger) {
     const args = [prg, device];
-    if (test)
+    if (test) {
         args.push(external_sdk_util_cjs_namespaceObject.isWin ? "/t" : "-t");
+        if (typeof test === "string") {
+            args.push(test);
+        }
+    }
     return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "monkeydo.bat" : "monkeydo"), args, logger || ((line) => console.log(line))).then(() => {
         return;
     }));
@@ -4835,6 +4847,15 @@ function findCalleesForNew(lookupDefs) {
         .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
 }
 
+;// CONCATENATED MODULE: ./src/optimizer-types.ts
+var StateNodeAttributes;
+(function (StateNodeAttributes) {
+    StateNodeAttributes[StateNodeAttributes["PUBLIC"] = 1] = "PUBLIC";
+    StateNodeAttributes[StateNodeAttributes["PROTECTED"] = 2] = "PROTECTED";
+    StateNodeAttributes[StateNodeAttributes["PRIVATE"] = 4] = "PRIVATE";
+    StateNodeAttributes[StateNodeAttributes["STATIC"] = 8] = "STATIC";
+})(StateNodeAttributes || (StateNodeAttributes = {}));
+
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
 
@@ -4901,6 +4922,7 @@ function renameVariable(state, locals, declName) {
 
 
 
+
 // Note: Keep in sync with replaceInlinedSubExpression below
 function inlinableSubExpression(expr) {
     while (true) {
@@ -5220,6 +5242,12 @@ function processInlineBody(state, func, call, root, params) {
     state.inlining = true;
     let insertedVariableDecls = null;
     const replacements = new Set();
+    // lookup determines static-ness of the lookup context based on seeing
+    // a static FunctionDeclaration, but the FunctionDeclaration's stack
+    // doesn't include the FunctionDeclaration itself.
+    const stack = func.attributes & StateNodeAttributes.STATIC
+        ? func.stack.concat(func)
+        : func.stack;
     try {
         state.pre = (node) => {
             if (failed)
@@ -5269,7 +5297,7 @@ function processInlineBody(state, func, call, root, params) {
                 }
                 return null;
             }
-            const replacement = fixNodeScope(state, node, func.stack);
+            const replacement = fixNodeScope(state, node, stack);
             if (!replacement) {
                 failed = true;
                 inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
@@ -5324,7 +5352,7 @@ function processInlineBody(state, func, call, root, params) {
         delete state.inlining;
     }
 }
-function unused(expression, top) {
+function unused(state, expression, top) {
     const estmt = (expression) => withLoc({
         type: "ExpressionStatement",
         expression,
@@ -5338,19 +5366,19 @@ function unused(expression, top) {
             return [];
         case "BinaryExpression":
             if (expression.operator === "as") {
-                return unused(expression.left);
+                return unused(state, expression.left);
             }
-            return unused(expression.left).concat(unused(expression.right));
+            return unused(state, expression.left).concat(unused(state, expression.right));
         case "LogicalExpression": {
-            const right = unused(expression.right);
+            const right = unused(state, expression.right);
             if (!right.length)
-                return unused(expression.left);
+                return unused(state, expression.left);
             const consequent = withLoc({
                 type: "BlockStatement",
                 body: [estmt(expression.right)],
             }, expression.right);
             let alternate;
-            if (expression.operator == "||") {
+            if (expression.operator == "||" || expression.operator == "or") {
                 alternate = { ...consequent };
                 consequent.body = [];
             }
@@ -5364,10 +5392,10 @@ function unused(expression, top) {
             ];
         }
         case "ConditionalExpression": {
-            const consequentExprs = unused(expression.consequent);
-            const alternateExprs = unused(expression.alternate);
+            const consequentExprs = unused(state, expression.consequent);
+            const alternateExprs = unused(state, expression.alternate);
             if (!consequentExprs.length && !alternateExprs.length) {
-                return unused(expression.test);
+                return unused(state, expression.test);
             }
             return [
                 withLoc({
@@ -5385,20 +5413,24 @@ function unused(expression, top) {
             ];
         }
         case "UnaryExpression":
-            return unused(expression.argument);
+            return unused(state, expression.argument);
         case "MemberExpression":
             if (expression.computed) {
-                return unused(expression.object).concat(unused(expression.property));
+                return unused(state, expression.object).concat(unused(state, expression.property));
             }
-            if (expression.object.type === "NewExpression") {
+            if ((state.sdkVersion || 0) < 4001007 &&
+                expression.object.type === "NewExpression") {
+                // prior to 4.1.7 top level new expressions were discarded,
+                // but (new X()).a was not. After 4.1.7, top level new is
+                // executed, but top level (new X()).a is an error.
                 break;
             }
-            return unused(expression.object);
+            return unused(state, expression.object);
         case "ArrayExpression":
-            return expression.elements.map((e) => unused(e)).flat(1);
+            return expression.elements.map((e) => unused(state, e)).flat(1);
         case "ObjectExpression":
             return expression.properties
-                .map((p) => unused(p.key).concat(unused(p.value)))
+                .map((p) => unused(state, p.key).concat(unused(state, p.value)))
                 .flat(1);
     }
     return top ? null : [estmt(expression)];
@@ -5558,7 +5590,7 @@ function inlineWithArgs(state, func, call, context) {
                 ];
             }
             else {
-                const side_exprs = unused(last.argument);
+                const side_exprs = unused(state, last.argument);
                 block.body.splice(block.body.length - 1, 1, ...side_exprs);
             }
         }
@@ -5693,7 +5725,7 @@ function pragmaChecker(state, ast, diagnostics) {
         return;
     diagnostics = diagnostics
         ?.slice()
-        .sort((d1, d2) => d1.loc.start < d2.loc.start ? -1 : d1.loc.start == d2.loc.start ? 0 : 1);
+        .sort((d1, d2) => d1.loc.start.offset - d2.loc.start.offset);
     let diagIndex = 0;
     let index = -1;
     let comment;
@@ -5706,6 +5738,12 @@ function pragmaChecker(state, ast, diagnostics) {
                 continue;
             const kind = match[1];
             let str = match[2];
+            const verCheck = (0,external_api_cjs_namespaceObject.checkCompilerVersion)(str.replace(/\s.*/, ""), state.sdkVersion || 0);
+            if (verCheck === false)
+                continue;
+            if (verCheck === true) {
+                str = str.replace(/^\S+\s+/, "");
+            }
             matchers = [];
             while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
                 matchers.push({ kind, quote: match[1], needle: match[2] });
@@ -7258,7 +7296,7 @@ function cleanupUnusedVars(state, node) {
                         if (node.expression.type === "AssignmentExpression") {
                             if (node.expression.left.type === "Identifier" &&
                                 hasProperty(toRemove, node.expression.left.name)) {
-                                return unused(node.expression.right);
+                                return unused(state, node.expression.right);
                             }
                         }
                         else if (node.expression.type === "UpdateExpression" &&
@@ -7273,7 +7311,7 @@ function cleanupUnusedVars(state, node) {
                             if (expr.type === "AssignmentExpression") {
                                 if (expr.left.type === "Identifier" &&
                                     hasProperty(toRemove, expr.left.name)) {
-                                    const rep = unused(expr.right);
+                                    const rep = unused(state, expr.right);
                                     if (!rep.length) {
                                         node.expressions.splice(i, 1);
                                     }
@@ -7303,13 +7341,16 @@ function cleanupUnusedVars(state, node) {
                     const vdecl = decl.declarations[i];
                     const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(vdecl.id);
                     if (hasProperty(toRemove, name)) {
-                        const rep = vdecl.init ? unused(vdecl.init) : [];
+                        const rep = vdecl.init ? unused(state, vdecl.init) : [];
                         if (rep.length) {
-                            if (rep.find((s) => s.type === "ExpressionStatement" &&
-                                (s.expression.type === "NewExpression" ||
-                                    (s.expression.type === "MemberExpression" &&
-                                        !s.expression.computed &&
-                                        s.expression.object.type === "NewExpression")))) {
+                            if ((state.sdkVersion || 0) < 4001007 &&
+                                rep.find((s) => s.type === "ExpressionStatement" &&
+                                    (s.expression.type === "NewExpression" ||
+                                        (s.expression.type === "MemberExpression" &&
+                                            !s.expression.computed &&
+                                            s.expression.object.type === "NewExpression")))) {
+                                // prior to 4.1.7 vanilla new expressions were discarded,
+                                // so don't create top level new expressions.
                                 continue;
                             }
                             if (parent.node.type === "ForStatement") {
@@ -7373,6 +7414,7 @@ function cleanupUnusedVars(state, node) {
 
 
 
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -7448,7 +7490,8 @@ function collectClassInfo(state) {
         if (elm.hasInvoke && elm.decls) {
             Object.values(elm.decls).forEach((funcs) => {
                 funcs.forEach((f) => {
-                    if (f.type === "FunctionDeclaration" && !f.isStatic) {
+                    if (f.type === "FunctionDeclaration" &&
+                        !(f.attributes & StateNodeAttributes.STATIC)) {
                         (0,external_api_cjs_namespaceObject.markInvokeClassMethod)(f);
                     }
                 });
@@ -7527,11 +7570,6 @@ async function analyze(fnMap, resourcesMap, config) {
                     const [scope] = state.stack.slice(-1);
                     scope.stack = state.stackClone().slice(0, -1);
                     if (scope.type == "FunctionDeclaration") {
-                        scope.isStatic =
-                            scope.stack.slice(-1)[0].type !== "ClassDeclaration" ||
-                                (scope.node.attrs &&
-                                    scope.node.attrs.access &&
-                                    scope.node.attrs.access.includes("static"));
                         if (markApi) {
                             node.body = null;
                             scope.info = (0,external_api_cjs_namespaceObject.getApiFunctionInfo)(scope);
@@ -7578,18 +7616,45 @@ function reportMissingSymbols(state, config) {
     const diagnosticType = config?.checkInvalidSymbols !== "OFF"
         ? config?.checkInvalidSymbols || "WARNING"
         : null;
+    const compiler2DiagnosticType = config?.checkCompilerLookupRules !== "OFF"
+        ? config?.checkCompilerLookupRules || "WARNING"
+        : null;
     if (diagnosticType &&
         !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
         const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
         Object.entries(state.fnMap).forEach(([, v]) => {
             (0,external_api_cjs_namespaceObject.visitReferences)(state, v.ast, null, false, (node, results, error) => {
-                if (!error)
-                    return undefined;
                 if (node.type === "BinaryExpression" && node.operator === "has") {
                     // Its not an error to check whether a property exists...
                     return undefined;
                 }
                 const nodeStr = (0,external_api_cjs_namespaceObject.formatAst)(node);
+                if (!error) {
+                    if (state.sdkVersion === 4001006 &&
+                        compiler2DiagnosticType &&
+                        node.type === "MemberExpression" &&
+                        (node.object.type === "Identifier" ||
+                            node.object.type === "MemberExpression") &&
+                        results.some((result) => {
+                            const parent = result.parent;
+                            if (!parent || parent.type !== "ClassDeclaration") {
+                                return false;
+                            }
+                            return result.results.some((sn) => {
+                                switch (sn.type) {
+                                    case "VariableDeclarator":
+                                    case "FunctionDeclaration":
+                                        return (sn.attributes &
+                                            (StateNodeAttributes.PRIVATE |
+                                                StateNodeAttributes.PROTECTED));
+                                }
+                                return false;
+                            });
+                        })) {
+                        diagnostic(state, node.loc, `The expression ${nodeStr} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
+                    }
+                    return undefined;
+                }
                 if (state.inType) {
                     if (!checkTypes || nodeStr.match(/^Void|Null$/)) {
                         return undefined;
@@ -7803,7 +7868,7 @@ function optimizeNode(state, node) {
                 left.value === null ||
                 ((left_type === "Number" || left_type === "Long") &&
                     (left.value === 0 || left.value === 0n));
-            if (falsy === (node.operator === "&&")) {
+            if (falsy === (node.operator === "&&" || node.operator === "and")) {
                 return left;
             }
             if (left_type !== "Boolean" &&
@@ -7813,10 +7878,12 @@ function optimizeNode(state, node) {
             }
             const [right, right_type] = getNodeValue(node.right);
             if (right && right_type === left_type) {
-                if (left_type === "Boolean" || node.operator === "||") {
+                if (left_type === "Boolean" ||
+                    node.operator === "||" ||
+                    node.operator === "or") {
                     return right;
                 }
-                if (node.operator !== "&&") {
+                if (node.operator !== "&&" && node.operator !== "and") {
                     throw new Error(`Unexpected operator "${node.operator}"`);
                 }
                 return { ...node, type: "BinaryExpression", operator: "&" };
@@ -8306,7 +8373,6 @@ async function optimizeMonkeyC(fnMap, resourcesMap, config) {
                         if ((obj.type === "ModuleDeclaration" ||
                             obj.type === "Program" ||
                             obj.type === "ClassDeclaration") &&
-                            obj.decls &&
                             obj.stack) {
                             const exists = (0,external_api_cjs_namespaceObject.hasProperty)(obj.decls, node.right.argument.name) ||
                                 // This is overkill, since we've already looked up
@@ -8407,7 +8473,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, config) {
                     }
                 }
                 else {
-                    const ret = unused(node.expression, true);
+                    const ret = unused(state, node.expression, true);
                     if (ret) {
                         return ret
                             .map((r) => replace(r, r))
@@ -8811,11 +8877,8 @@ async function generateOptimizedProject(options) {
         const error = new Error(xml.body.children("iq:barrel").length()
             ? "Optimize the project that uses this barrel, not the barrel itself"
             : "Manifest is missing an `iq:application` tag");
-        error.location = {
-            start: { line: 1, column: 1 },
-            end: { line: 1, column: 1 },
-            source: manifest,
-        };
+        error.location =
+            xml.body.elements[0].loc || undefined;
         throw error;
     }
     const dependencyFiles = [manifest, ...jungles];
@@ -9019,6 +9082,7 @@ const configOptionsToCheck = [
     "ignoredAnnotations",
     "ignoredSourcePaths",
     "checkInvalidSymbols",
+    "checkCompilerLookupRules",
     "sizeBasedPRE",
     "extensionVersion",
 ];
@@ -9079,7 +9143,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1668132957835 < opt_time) {
+        if (source_time < opt_time && 1669424079462 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -9104,7 +9168,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.0.39",
+                optimizerVersion: "1.0.40",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));

package/build/sdk-util.cjs

@@ -73,10 +73,11 @@ function peg$subclass(t,u){function r(){this.constructor=t}r.prototype=u.prototy
 ;// CONCATENATED MODULE: ./src/xml-util.ts
 
 class Document {
-    constructor(prolog, body, misc) {
+    constructor(prolog, body, misc, source) {
         this.prolog = prolog;
         this.body = body;
         this.misc = misc;
+        this.source = source;
     }
 }
 function elementKids(e) {
@@ -155,7 +156,7 @@ function parseXml(content, fileName = null) {
     const [prolog, body, misc] = peg$parse(content, {
         grammarSource: fileName || "unknown",
     });
-    return new Document(prolog, new Nodes(body), misc);
+    return new Document(prolog, new Nodes(body), misc, content);
 }
 function reference(s) {
     if (typeof s === "string")

package/build/src/api.d.ts

@@ -1,9 +1,11 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
 import { JungleResourceMap } from "./jungles";
-import { FunctionInfo, FunctionStateNode, LookupDefinition, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl } from "./optimizer-types";
+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 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;
@@ -11,6 +13,12 @@ export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinit
 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

@@ -52,5 +52,5 @@ export declare type ResolvedJungle = JungleInfoBase & {
 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

@@ -2,4 +2,4 @@ import { LineHandler } from "./util";
 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/optimizer-types.d.ts

@@ -1,5 +1,7 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 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;
@@ -23,6 +25,9 @@ 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;
@@ -35,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;
@@ -45,6 +56,7 @@ interface BaseStateNode {
     stack?: ProgramStateStack | undefined;
     usings?: Record<string, ImportUsing>;
     imports?: ImportUsing[];
+    attributes: StateNodeAttributes;
 }
 export interface ProgramStateNode extends BaseStateNode {
     type: "Program";
@@ -82,7 +94,6 @@ export interface FunctionStateNode extends BaseStateNode {
     fullName: string;
     stack?: ProgramStateStack;
     decls?: undefined;
-    isStatic?: boolean;
     info?: FunctionInfo;
     next_info?: FunctionInfo;
 }
@@ -133,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>;
@@ -166,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/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/xml-util.d.ts

@@ -118,7 +118,8 @@ export declare class Document {
     prolog: Prolog;
     body: Nodes;
     misc: Array<Misc>;
-    constructor(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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.39",
+  "version": "1.0.40",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -17,6 +17,7 @@
   },
   "scripts": {
     "watch": "webpack --mode development --watch",
+    "prettier-live": "test -z \"$(git status --untracked-files=no --porcelain || echo dirty)\" && npm install ../prettier-plugin-monkeyc && git commit -am 'prettier-plugin-monkeyc-live'",
     "build-debug": "webpack --mode development",
     "build-release": "webpack --mode production",
     "prepack": "webpack --mode production",
@@ -37,7 +38,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.36"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.37"
   },
   "devDependencies": {
     "@types/glob": "^8.0.0",