@markw65/monkeyc-optimizer 1.1.6 → 1.1.8

package/build/optimizer.cjs

@@ -5035,15 +5035,6 @@ function findCalleesByNode(state, callee) {
     return ((hasProperty(state.allFunctions, name) && state.allFunctions[name]) || null);
 }
 
-;// 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
 
 
@@ -5084,7 +5075,7 @@ function renameVariable(state, locals, declName) {
             let ok = false;
             let i;
             for (i = state.stack.length; i--;) {
-                const elm = state.stack[i];
+                const elm = state.stack[i].sn;
                 if (ok) {
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(elm.decls, name)) {
                         break;
@@ -5110,7 +5101,6 @@ function renameVariable(state, locals, declName) {
 
 
 
-
 // Note: Keep in sync with replaceInlinedSubExpression below
 function inlinableSubExpression(expr) {
     while (true) {
@@ -5189,9 +5179,9 @@ function getArgSafety(state, func, args, requireAll) {
                 // if decl is a local, it also can't be changed
                 // by a call to another function.
                 for (let i = 0;; i++) {
-                    if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                    if (!state.stack[i] || decl.stack[i]?.sn !== state.stack[i].sn)
                         return false;
-                    if (state.stack[i].type === "FunctionDeclaration")
+                    if (state.stack[i].sn.type === "FunctionDeclaration")
                         return true;
                 }
             }
@@ -5328,7 +5318,7 @@ function getArgSafety(state, func, args, requireAll) {
             }
             return null;
         };
-        state.stack = func.stack;
+        state.stack = func.stack.concat({ sn: func });
         state.traverse(func.node.body);
     }
     finally {
@@ -5439,9 +5429,7 @@ function processInlineBody(state, func, call, root, params) {
     // 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;
+    const lookupStack = func.stack.concat({ sn: func });
     try {
         state.pre = (node) => {
             if (failed)
@@ -5497,7 +5485,7 @@ function processInlineBody(state, func, call, root, params) {
                 }
                 return null;
             }
-            const replacement = fixNodeScope(state, node, stack);
+            const replacement = fixNodeScope(state, node, lookupStack);
             if (!replacement) {
                 failed = true;
                 inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
@@ -5831,10 +5819,11 @@ function inlineFunction(state, func, call, context) {
     if (!typecheckFalse) {
         return ret;
     }
-    const callerSn = state.stack.find((sn) => sn.type === "FunctionDeclaration");
-    if (!callerSn) {
+    const callerElem = state.stack.find((elem) => elem.sn.type === "FunctionDeclaration");
+    if (!callerElem) {
         return ret;
     }
+    const callerSn = callerElem.sn;
     const caller = callerSn.node;
     if (!caller.attrs) {
         caller.attrs = withLoc({
@@ -5953,6 +5942,15 @@ function fixNodeScope(state, lookupNode, nodeStack) {
     return null;
 }
 
+;// 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/pragma-checker.ts
 
 
@@ -6891,7 +6889,7 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                 });
             }
             if (wantsAllRefs) {
-                const scope = state.stack[state.stack.length - 1];
+                const scope = state.top().sn;
                 if (scope.node === node &&
                     scope.type === "BlockStatement" &&
                     scope.decls &&
@@ -8867,7 +8865,7 @@ function unionInto(to, from) {
         return true;
     }
     const newTags = to.type | from.type;
-    if (!(from.type & ~SingleTonTypeTagsConst)) {
+    if (!(from.type & ~SingletonTypeTagsConst)) {
         // - Adding singletons never affects the data.
         if (newTags === to.type)
             return false;
@@ -9129,7 +9127,7 @@ function clearValuesUnder(v, tag, clearTag = false) {
     const newTag = clearTag ? v.type & ~tag : v.type | tag;
     // If the incoming type consists of singletons,
     // we can always merge it without affecting our data.
-    tag &= ~SingleTonTypeTagsConst;
+    tag &= ~SingletonTypeTagsConst;
     if (!tag || v.value == null) {
         v.type = newTag;
         return;
@@ -9313,7 +9311,7 @@ function typeTagName(tag) {
     }
 }
 const LastTypeTag = 262144 /* TypeTag.Typedef */;
-const SingleTonTypeTagsConst = 1 /* TypeTag.Null */ | 2 /* TypeTag.False */ | 4 /* TypeTag.True */;
+const SingletonTypeTagsConst = 1 /* TypeTag.Null */ | 2 /* TypeTag.False */ | 4 /* TypeTag.True */;
 const UnionDataTypeTagsConst = 512 /* TypeTag.Array */ |
     1024 /* TypeTag.Dictionary */ |
     2048 /* TypeTag.Method */ |
@@ -9336,7 +9334,7 @@ const ObjectLikeTagsConst = 6 /* TypeTag.Boolean */ |
     1024 /* TypeTag.Dictionary */ |
     2048 /* TypeTag.Method */ |
     65536 /* TypeTag.Enum */;
-const EnumTagsConst = SingleTonTypeTagsConst | (ValueTypeTagsConst & ~131072 /* TypeTag.Symbol */);
+const EnumTagsConst = SingletonTypeTagsConst | (ValueTypeTagsConst & ~131072 /* TypeTag.Symbol */);
 function isExact(v) {
     // check that there is exactly one bit set
     return v.type !== 0 && !(v.type & (v.type - 1));
@@ -9345,27 +9343,18 @@ function isUnion(v) {
     return v.type !== 0 && !isExact(v);
 }
 function isSingleton(v) {
-    return isExact(v) && (v.type & SingleTonTypeTagsConst) !== 0;
+    return isExact(v) && (v.type & SingletonTypeTagsConst) !== 0;
 }
 function hasValue(v) {
     return (isExact(v) &&
-        ((v.type & SingleTonTypeTagsConst) !== 0 || v.value !== undefined));
+        ((v.type & SingletonTypeTagsConst) !== 0 || v.value !== undefined));
 }
 function hasNoData(v, t) {
     if (v.value == null)
         return true;
     return ((hasUnionData(v.type)
         ? v.value.mask & t
-        : v.type & t & ~SingleTonTypeTagsConst) === 0);
-}
-function lookupByFullName(state, fullName) {
-    return fullName.split(".").reduce((results, part) => {
-        return results
-            .flatMap((result) => (0,external_api_cjs_namespaceObject.isStateNode)(result)
-            ? result.decls?.[part] || result.type_decls?.[part]
-            : null)
-            .filter((sn) => !!sn);
-    }, [state.stack[0]]);
+        : v.type & t & ~SingletonTypeTagsConst) === 0);
 }
 function cloneType(t) {
     return { ...t };
@@ -9588,7 +9577,7 @@ function typeFromSingleTypeSpec(state, type, stack) {
 function typeFromTypespec(state, ts, stack) {
     if (!state.config?.trustDeclaredTypes) {
         if (ts.ts.length === 1 && typeof ts.ts[0] === "string") {
-            const e = lookupByFullName(state, ts.ts[0]);
+            const e = (0,external_api_cjs_namespaceObject.lookupByFullName)(state, ts.ts[0]);
             if (e && e.length === 1 && e[0].type === "EnumDeclaration") {
                 return {
                     type: 65536 /* TypeTag.Enum */,
@@ -9934,7 +9923,7 @@ function getObjectValue(t) {
 }
 function forEachUnionComponent(v, bits, fn) {
     // never iterate the singleton bits, because they don't have data
-    bits &= ~SingleTonTypeTagsConst;
+    bits &= ~SingletonTypeTagsConst;
     if (!bits)
         return;
     if ((v.type | bits) & UnionDataTypeTagsConst) {
@@ -9964,7 +9953,7 @@ function forEachUnionComponent(v, bits, fn) {
 function getUnionComponent(v, tag) {
     if (v.value == null)
         return null;
-    let bits = v.type & ~SingleTonTypeTagsConst;
+    let bits = v.type & ~SingletonTypeTagsConst;
     if (!bits)
         return null;
     if (bits & (bits - 1)) {
@@ -10038,7 +10027,7 @@ function getStateNodeDeclsFromType(state, object) {
                 next &= ~6 /* TypeTag.Boolean */;
             }
             const name = `Toybox.Lang.${typeTagName(bit)}`;
-            const sns = lookupByFullName(state, name);
+            const sns = (0,external_api_cjs_namespaceObject.lookupByFullName)(state, name);
             sns.forEach((sn) => (0,external_api_cjs_namespaceObject.isStateNode)(sn) && decls.push(sn));
             bits = next;
         } while (bits);
@@ -10244,7 +10233,7 @@ function common_types(left, right, allowed) {
     }
     if (lt & 8 /* TypeTag.Number */) {
         result |=
-            rt & 6 /* TypeTag.Boolean */ ? 6 /* TypeTag.Boolean */ : rt & ~SingleTonTypeTagsConst;
+            rt & 6 /* TypeTag.Boolean */ ? 6 /* TypeTag.Boolean */ : rt & ~SingletonTypeTagsConst;
     }
     if (lt & 16 /* TypeTag.Long */) {
         if (rt & 6 /* TypeTag.Boolean */) {
@@ -10637,7 +10626,7 @@ function calleeObjectType(istate, callee) {
     }
     if (callee.type === "Identifier" && istate.func) {
         const func = istate.func;
-        const [self] = func.stack.slice(-1);
+        const [{ sn: self }] = func.stack.slice(-1);
         return typeFromTypeStateNode(istate.state, self, (func.attributes & StateNodeAttributes.STATIC) !== 0 ||
             self.type !== "ClassDeclaration");
     }
@@ -10769,14 +10758,14 @@ function checkCallArgs(istate, node, callees, args) {
     return resultType;
 }
 function isOverride(cur, funcs) {
-    const cls = cur.stack?.[cur.stack.length - 1];
+    const cls = cur.stack?.[cur.stack.length - 1]?.sn;
     if (cls?.type === "ClassDeclaration" && cls.superClasses) {
         const supers = (0,external_api_cjs_namespaceObject.getSuperClasses)(cls);
         if (supers &&
             (0,external_util_cjs_namespaceObject.some)(funcs, (func) => {
                 if (func === cur)
                     return false;
-                const fcls = func.stack?.[func.stack.length - 1];
+                const fcls = func.stack?.[func.stack.length - 1].sn;
                 return fcls ? supers.has(fcls) : false;
             })) {
             return true;
@@ -11352,7 +11341,7 @@ function byteArrayType(state) {
         value: {
             klass: {
                 type: 16384 /* TypeTag.Class */,
-                value: lookupByFullName(state, "Toybox.Lang.ByteArray"),
+                value: (0,external_api_cjs_namespaceObject.lookupByFullName)(state, "Toybox.Lang.ByteArray"),
             },
         },
     };
@@ -11531,7 +11520,7 @@ function evaluateNode(istate, node) {
         case "ThisExpression": {
             const self = (() => {
                 for (let i = state.stack.length; i--;) {
-                    const si = state.stack[i];
+                    const si = state.stack[i].sn;
                     if (si.type === "ClassDeclaration") {
                         const klass = { type: 16384 /* TypeTag.Class */, value: si };
                         if ((istate.func?.attributes || 0) & StateNodeAttributes.STATIC) {
@@ -11741,7 +11730,7 @@ function evaluateNode(istate, node) {
             if (node.init) {
                 const init = popIstate(istate, node.init);
                 if (node.id.type === "BinaryExpression" && istate.typeChecker) {
-                    const top = istate.state.stack[istate.state.stack.length - 1];
+                    const top = istate.state.top().sn;
                     if (top.type !== "BlockStatement") {
                         const declType = typeFromTypespec(istate.state, node.id.right);
                         if (!istate.typeChecker(init.value, declType)) {
@@ -12160,7 +12149,7 @@ function filterDecls(decls, possible, name) {
                     const stack = d.stack;
                     possible.forEach((poss) => {
                         for (let i = stack.length; i--;) {
-                            const sn = stack[i];
+                            const sn = stack[i].sn;
                             if (sn.decls === poss.decls) {
                                 if (!cur[0]) {
                                     cur = [new Set(), new Set()];
@@ -12381,9 +12370,21 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         if (Array.isArray(decl) ||
             (decl.type !== "MemberDecl" && decl.type !== "Unknown")) {
             if (!clearEquiv) {
+                /*
+                 * If we're not clearing the equivalencies then this update
+                 * must be applied to every element of the set
+                 */
                 const v = blockState.get(decl);
                 if (v?.equivSet) {
-                    blockState.set(decl, { ...v, curType: value });
+                    let s = decl;
+                    do {
+                        const next = blockState.get(s);
+                        if (!next || !next.equivSet) {
+                            throw new Error(`Inconsistent equivSet for ${tsKey(decl)}: missing value for ${tsKey(s)}`);
+                        }
+                        blockState.set(s, { ...next, curType: value });
+                        s = next.equivSet.next;
+                    } while (s !== decl);
                     return;
                 }
             }
@@ -12489,7 +12490,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 return tmpState;
             }
             if (isExact(right) &&
-                right.type & SingleTonTypeTagsConst &&
+                right.type & SingletonTypeTagsConst &&
                 left.type & right.type) {
                 // left is not equal to right, and right is one of the
                 // singleton types; so we can remove that type from left.
@@ -13603,7 +13604,7 @@ function tryDeEnumerate(istate, node, elem) {
 
 
 function cleanupUnusedVars(state, node) {
-    const [parent] = state.stack.slice(-1);
+    const parent = state.stack.slice(-1).pop().sn;
     if (parent.node !== node) {
         return false;
     }
@@ -13830,14 +13831,14 @@ function collectDeclarationsByName(state) {
             }
         }
     };
-    helper(state.stack[0]);
+    helper(state.stack[0].sn);
 }
 function collectClassInfo(state) {
-    const toybox = state.stack[0].decls["Toybox"][0];
+    const toybox = state.stack[0].sn.decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
     const object = lang.decls["Object"];
     state.allClasses.forEach((elm) => {
-        if (elm.stack[elm.stack.length - 1].type === "ClassDeclaration") {
+        if (elm.stack[elm.stack.length - 1].sn.type === "ClassDeclaration") {
             // nested classes don't get access to their contained
             // context. Put them in the global scope instead.
             elm.stack = elm.stack.slice(0, 1);
@@ -13984,7 +13985,7 @@ async function analyze(fnMap, resourcesMap, manifestXML, config) {
                 case "FunctionDeclaration":
                 case "ModuleDeclaration":
                 case "ClassDeclaration": {
-                    const [scope] = state.stack.slice(-1);
+                    const scope = state.top().sn;
                     scope.stack = state.stackClone().slice(0, -1);
                     if (scope.type === "FunctionDeclaration") {
                         if (markApi) {
@@ -14445,7 +14446,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 node.params &&
                     node.params.forEach((p) => (map[(0,external_api_cjs_namespaceObject.variableDeclarationName)(p)] = true));
                 state.localsStack.push({ node, map });
-                const [parent, self] = state.stack.slice(-2);
+                const [{ sn: parent }, { sn: self }] = state.stack.slice(-2);
                 if (state.currentFunction) {
                     throw new Error(`Nested functions: ${self.fullName} was activated during processing of ${state.currentFunction.fullName}`);
                 }
@@ -14511,7 +14512,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     node.optimizable = true;
                 }
                 if (!state.currentFunction) {
-                    throw new Error(`Finished function ${state.stack.slice(-1)[0].fullName}, but it was not marked current`);
+                    throw new Error(`Finished function ${state.top().sn.fullName}, but it was not marked current`);
                 }
                 state.currentFunction.info = state.currentFunction.next_info || false;
                 delete state.currentFunction.next_info;
@@ -15381,7 +15382,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
         // 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 && 1674707539512 < opt_time) {
+        if (source_time < opt_time && 1675030247366 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -15408,7 +15409,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.1.6",
+                optimizerVersion: "1.1.8",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));
@@ -15477,7 +15478,7 @@ async function getProjectAnalysis(targets, analysis, manifestXML, options) {
         state.pre = (node) => {
             switch (node.type) {
                 case "FunctionDeclaration": {
-                    const self = state.stack.slice(-1).pop();
+                    const self = state.top().sn;
                     const istate = type_flow_buildTypeInfo(state, self, false);
                     if (istate) {
                         istate.state = state;

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 | EnumStateNode | mctree.EnumStringMember | mctree.Identifier | mctree.AsIdentifier | import("./optimizer-types").BlockStateNode | VariableStateNode)[];
+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/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/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): "Never" | "Null" | "False" | "True" | "Boolean" | "Number" | "Long" | "Float" | "Double" | "Decimal" | "Numeric" | "Char" | "String" | "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

@@ -4,7 +4,7 @@ import { InterpState } from "./type-flow/interp";
 import { ExactOrUnion } from "./type-flow/types";
 export declare const missingNullWorkaround = true;
 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 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.6",
+  "version": "1.1.8",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",