@markw65/monkeyc-optimizer 1.0.44 → 1.0.45

package/build/api.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
+0 && (module.exports = {checkCompilerVersion,collectNamespaces,findUsingForNode,formatAst,getApiFunctionInfo,getApiMapping,hasProperty,isLocal,isLookupCandidate,isStateNode,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -265,6 +265,7 @@ __webpack_require__.d(__webpack_exports__, {
   "getApiFunctionInfo": () => (/* binding */ api_getApiFunctionInfo),
   "getApiMapping": () => (/* binding */ api_getApiMapping),
   "hasProperty": () => (/* reexport */ ast_hasProperty),
+  "isLocal": () => (/* binding */ api_isLocal),
   "isLookupCandidate": () => (/* binding */ api_isLookupCandidate),
   "isStateNode": () => (/* binding */ api_isStateNode),
   "markInvokeClassMethod": () => (/* binding */ api_markInvokeClassMethod),
@@ -533,6 +534,64 @@ function ast_getNodeValue(node) {
     }
     throw new Error(`Literal has unknown type '${type}'`);
 }
+function wrap(node, loc) {
+    if (loc) {
+        node.loc = loc;
+        node.start = loc.start.offset;
+        node.end = loc.end.offset;
+    }
+    return node;
+}
+function locRange(start, end) {
+    return {
+        source: start.source || end.source,
+        start: start.start,
+        end: end.end,
+    };
+}
+function adjustLoc(loc, start = 1, end = -1) {
+    return {
+        source: loc.source,
+        start: {
+            offset: loc.start.offset + start,
+            line: loc.start.line,
+            column: loc.start.column + start,
+        },
+        end: {
+            offset: loc.end.offset + end,
+            line: loc.end.line,
+            column: loc.end.column + end,
+        },
+    };
+}
+function makeIdentifier(name, loc) {
+    return wrap({ type: "Identifier", name }, loc);
+}
+function makeMemberExpression(object, property) {
+    return wrap({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+    }, object.loc && locRange(object.loc, property.loc));
+}
+function makeScopedName(dotted, l) {
+    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
+    const result = dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
+        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
+        if (!cur) {
+            cur = id;
+        }
+        else {
+            cur = makeMemberExpression(cur, id);
+        }
+        offset += next.length + 1;
+        return { cur, offset };
+    }, { cur: null, offset: 0 }).cur;
+    if (!result)
+        throw new Error("Failed to make a ScopedName");
+    return result;
+}
 
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
@@ -587,6 +646,8 @@ function function_info_recordCalledFuncs(func, callees) {
 }
 function function_info_functionMayModify(state, func, decl) {
     const info = func.info;
+    if (info === false)
+        return false;
     if (!info || info.modifiedUnknown)
         return true;
     if (info.resolvedDecls) {
@@ -599,7 +660,7 @@ function function_info_functionMayModify(state, func, decl) {
     const visited = new Set();
     const resolved = new Set();
     const resolveDecls = (f) => {
-        if (visited.has(f))
+        if (f.info === false || visited.has(f))
             return true;
         if (!f.info)
             return false;
@@ -661,6 +722,16 @@ function function_info_findCalleesForNew(lookupDefs) {
         .flatMap(initializer)
         .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
 }
+function function_info_findCalleesByNode(state, callee) {
+    const name = callee.type === "Identifier"
+        ? callee.name
+        : callee.type === "MemberExpression" && !callee.computed
+            ? callee.property.name
+            : null;
+    if (!name)
+        return null;
+    return ((hasProperty(state.allFunctions, name) && state.allFunctions[name]) || null);
+}
 
 ;// CONCATENATED MODULE: ./src/optimizer-types.ts
 var optimizer_types_StateNodeAttributes;
@@ -1624,13 +1695,17 @@ function pragma_checker_pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/[".]/g, "_")}(?:_\\d+)?)`));
+        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/\W/g, "_")}(?:_\\d+)?)`));
         return re.test(haystack);
     };
     next();
     traverseAst(ast, (node) => {
-        if (index >= comments.length)
+        if (index >= comments.length ||
+            node.type === "Line" ||
+            node.type === "Block" ||
+            node.type === "MultiLine") {
             return false;
+        }
         if (node.start && node.start >= (comment.end || Infinity)) {
             const { kind, quote, needle } = matchers.shift();
             if (kind === "match") {
@@ -1778,7 +1853,7 @@ function control_flow_buildReducedGraph(state, func, notice) {
     try {
         const localState = new LocalState(func.node);
         const ret = localState.curBlock;
-        state.stack = func.stack;
+        state.stack = [...func.stack];
         const stmtStack = [func.node];
         let tryActive = 0;
         state.pre = (node) => {
@@ -1793,6 +1868,8 @@ function control_flow_buildReducedGraph(state, func, notice) {
                 stmtStack.push(node);
             }
             switch (node.type) {
+                case "FunctionDeclaration":
+                    return ["body"];
                 case "AttributeList":
                     return [];
                 case "SwitchStatement": {
@@ -2009,11 +2086,6 @@ function control_flow_buildReducedGraph(state, func, notice) {
                 }
                 case "VariableDeclarator":
                     return ["init"];
-                case "MemberExpression":
-                    if (!node.computed) {
-                        return ["object"];
-                    }
-                    break;
                 case "UnaryExpression":
                     if (node.operator === ":") {
                         return [];
@@ -2049,6 +2121,14 @@ function control_flow_buildReducedGraph(state, func, notice) {
                 case "ContinueStatement":
                     localState.terminal(node.type);
                     return [];
+                case "CallExpression":
+                    if (node.callee.type === "Identifier") {
+                        const extra = state.stack.splice(func.stack.length);
+                        state.traverse(node.callee);
+                        state.stack.push(...extra);
+                        return ["arguments"];
+                    }
+                    break;
             }
             return null;
         };
@@ -2210,142 +2290,94 @@ function getPreOrder(head) {
 
 // EXTERNAL MODULE: ./node_modules/priorityqueuejs/index.js
 var priorityqueuejs = __webpack_require__(2789);
-;// CONCATENATED MODULE: ./src/pre.ts
+;// CONCATENATED MODULE: ./src/data-flow.ts
 
 
 
 
 
-/**
- * This implements a pseudo Partial Redundancy Elimination
- * pass. It isn't quite like traditional PRE because we're
- * aiming to minimize size, not dynamic instructions. So
- * for us, its worthwhile to take something like:
- *
- * switch (x) {
- *   case 1: foo(A.B); break;
- *   case 2: foo(C); break;
- *   case 3: bar(A.B); break;
- * }
- *
- * and rewrite it as
- *
- * var tmp = A.B;
- * switch (x) {
- *   case 1: foo(tmp); break;
- *   case 2: foo(C); break;
- *   case 3: bar(tmp); break;
- * }
- *
- * because even though A.B wasn't used on all paths where we
- * inserted the temporary, we still reduced the code size.
- */
-const logging = false;
-function declFullName(decl) {
+
+function data_flow_declFullName(decl) {
+    if (Array.isArray(decl)) {
+        decl = decl[0];
+    }
+    if (decl.type === "Literal") {
+        return decl.raw || decl.value?.toString() || "null";
+    }
+    if (isStateNode(decl))
+        return decl.fullName;
     switch (decl.type) {
-        case "Literal":
-            return decl.raw || decl.value?.toString() || "null";
-        case "VariableDeclarator":
-            return decl.fullName;
+        case "BinaryExpression":
+            return decl.left.name;
+        case "EnumStringMember":
+            return decl.init
+                ? `${decl.id.name}:${formatAst(decl.init)}`
+                : decl.id.name;
         default:
             throw new Error(`Unexpected EventDecl type: ${decl.type}`);
     }
 }
-function declName(decl) {
+function data_flow_declName(decl) {
+    if (Array.isArray(decl)) {
+        decl = decl[0];
+    }
+    if (decl.type === "Literal") {
+        return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
+    }
+    if (isStateNode(decl))
+        return decl.name;
     switch (decl.type) {
-        case "Literal":
-            return (decl.raw || decl.value?.toString() || "null").replace(/[^\w]/g, "_");
-        case "VariableDeclarator":
-            return decl.name;
+        case "BinaryExpression":
+            return decl.left.name;
+        case "EnumStringMember":
+            return decl.id.name;
         default:
             throw new Error(`Unexpected EventDecl type: ${decl.type}`);
     }
 }
-function logAntState(s, decl) {
-    const defs = Array.from(s.ant).reduce((defs, event) => {
-        if (event.type === "def" || event.type === "mod")
-            defs++;
-        return defs;
-    }, 0);
-    console.log(`  - ${declFullName(decl)}: ${candidateCost(s)} bytes, ${s.ant.size - defs} refs, ${defs} defs, ${s.live ? "" : "!"}live, ${s.isIsolated ? "" : "!"}isolated`);
-    console.log(`    - members: ${Array.from(s.members)
-        .map(([block, live]) => block.order + (live ? "t" : "f"))
-        .join(", ")}`);
-}
-function logAntDecls(antDecls) {
-    antDecls.forEach(logAntState);
-}
-function pre_sizeBasedPRE(state, func) {
-    if (!func.node.body)
-        return;
-    if (!state.config ||
-        !state.config.sizeBasedPRE ||
-        (typeof state.config.sizeBasedPRE === "string" &&
-            state.config.sizeBasedPRE !== func.fullName)) {
-        return;
-    }
-    const { graph: head, identifiers } = buildPREGraph(state, func);
-    const candidates = computeAttributes(state, head);
-    if (candidates) {
-        if (logging) {
-            console.log(`Found ${candidates.size} candidates in ${func.fullName}`);
-            logAntDecls(candidates);
-        }
-        const nodeMap = new Map();
-        const declMap = new Map();
-        const variableDecl = withLoc({
-            type: "VariableDeclaration",
-            declarations: [],
-            kind: "var",
-        }, func.node.body);
-        variableDecl.end = variableDecl.start;
-        variableDecl.loc.end = variableDecl.loc.start;
-        candidates.forEach((s, decl) => {
-            let name;
-            let i = 0;
-            do {
-                name = `pre_${declName(decl)}${i ? "_" + i : ""}`;
-                if (!identifiers.has(name)) {
-                    identifiers.add(name);
-                    break;
-                }
-                i++;
-            } while (true);
-            declMap.set(decl, name);
-            variableDecl.declarations.push(withLoc({
-                type: "VariableDeclarator",
-                id: withLoc({ type: "Identifier", name }, variableDecl),
-                kind: "var",
-            }, variableDecl));
-            s.ant.forEach((event) => {
-                const events = nodeMap.get(event.node);
-                if (!events) {
-                    nodeMap.set(event.node, [event]);
-                }
-                else {
-                    events.push(event);
-                }
-            });
-        });
-        applyReplacements(func.node, nodeMap, declMap);
-        func.node.body.body.unshift(variableDecl);
-    }
-}
 function unhandledExpression(node) {
     throw new Error(`Unhandled expression type: ${node.type}`);
 }
-function buildPREGraph(state, func) {
+function data_flow_buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wantsAllRefs) {
+    const uniqueDeclMap = new Map();
     const findDecl = (node) => {
         if (node.type === "Identifier" ||
             (node.type === "MemberExpression" && !node.computed)) {
             const [, results] = state.lookup(node);
-            if (results &&
-                results.length === 1 &&
-                results[0].parent?.type != "BlockStatement" &&
-                results[0].results.length === 1 &&
-                results[0].results[0].type === "VariableDeclarator") {
-                return results[0].results[0];
-            }
+            const decls = (results &&
+                results.reduce((decls, result) => result.results.reduce((decls, result) => {
+                    if (!wantsAllRefs &&
+                        (result.type !== "VariableDeclarator" || isLocal(result))) {
+                        return decls;
+                    }
+                    if (!decls)
+                        return result;
+                    if (Array.isArray(decls)) {
+                        decls.push(result);
+                        return decls;
+                    }
+                    else {
+                        return [decls, result];
+                    }
+                }, decls), null)) ||
+                null;
+            if (!Array.isArray(decls))
+                return decls;
+            // We use EventDecl as a Map key, so we need to
+            // uniquify it. Note that from any given function,
+            // if state.lookup finds a set of non locals, it will
+            // always find the same set, so we can use the first
+            // such as the unique identifier.
+            const canon = uniqueDeclMap.get(decls[0]);
+            if (!canon) {
+                uniqueDeclMap.set(decls[0], decls);
+                return decls;
+            }
+            if (canon.length != decls.length ||
+                !canon.every((v, i) => v === decls[i])) {
+                throw new Error(`Canonical representation of ${data_flow_declFullName(canon)} did not match`);
+            }
+            return canon;
         }
         return null;
     };
@@ -2353,18 +2385,22 @@ function buildPREGraph(state, func) {
     const identifiers = new Set();
     const liveDefs = new Map();
     const liveStmts = new Map();
-    const liveDef = (def, stmt) => {
-        let curNodes = liveDefs.get(def);
-        if (!curNodes) {
-            liveDefs.set(def, (curNodes = new Set()));
-        }
-        curNodes.add(stmt);
-        let defs = liveStmts.get(stmt);
-        if (!defs) {
-            liveStmts.set(stmt, (defs = new Map()));
+    const liveDef = trackInsertionPoints
+        ? (def, stmt) => {
+            let curNodes = liveDefs.get(def);
+            if (!curNodes) {
+                liveDefs.set(def, (curNodes = new Set()));
+            }
+            curNodes.add(stmt);
+            let defs = liveStmts.get(stmt);
+            if (!defs) {
+                liveStmts.set(stmt, (defs = new Map()));
+            }
+            defs.set(def, (defs.get(def) || 0) + 1);
         }
-        defs.set(def, (defs.get(def) || 0) + 1);
-    };
+        : () => {
+            /* do nothing */
+        };
     return {
         identifiers,
         graph: buildReducedGraph(state, func, (node, stmt, mayThrow) => {
@@ -2378,7 +2414,7 @@ function buildPREGraph(state, func) {
                     }
                     const v = liveDefs.get(def);
                     if (!v || !v.has(node)) {
-                        throw new Error(`No stmt in liveDef for ${def ? declFullName(def) : "null"}`);
+                        throw new Error(`No stmt in liveDef for ${def ? data_flow_declFullName(def) : "null"}`);
                     }
                     v.delete(node);
                     if (!v.size) {
@@ -2399,7 +2435,7 @@ function buildPREGraph(state, func) {
                 case "ParenthesizedExpression":
                     break;
                 case "Literal":
-                    if (refCost(node) > LocalRefCost) {
+                    if (wantsLiteral(node)) {
                         const result = getNodeValue(node);
                         const key = result[1] +
                             (result[0].value === null
@@ -2421,34 +2457,40 @@ function buildPREGraph(state, func) {
                 case "Identifier":
                     identifiers.add(node.name);
                 // fall through
-                case "MemberExpression":
-                    {
-                        const decl = findDecl(node);
-                        if (decl && decl.type === "VariableDeclarator") {
-                            const defStmts = (decl.node.kind === "var" && liveDefs.get(null)) ||
-                                liveDefs.get(decl);
-                            if (defStmts) {
-                                break;
-                                /*
-                                // hold off on this for now. we need to communicate
-                                // which defs need to be fixed, which involves yet-another
-                                // table.
-              
-                                if (defStmts.size !== 1) break;
-                                const fixable = isFixableStmt([...defStmts][0]);
-                                if (fixable === false) break;
-                                cost += fixable;
-                              */
+                case "MemberExpression": {
+                    const decls = findDecl(node);
+                    if (!decls)
+                        break;
+                    if (trackInsertionPoints &&
+                        some(decls, (decl) => {
+                            if (decl.type === "VariableDeclarator") {
+                                const defStmts = (decl.node.kind === "var" && liveDefs.get(null)) ||
+                                    liveDefs.get(decl);
+                                if (defStmts) {
+                                    return true;
+                                    /*
+                                      // hold off on this for now. we need to communicate
+                                      // which defs need to be fixed, which involves yet-another
+                                      // table.
+                
+                                      if (defStmts.size !== 1) break;
+                                      const fixable = isFixableStmt([...defStmts][0]);
+                                      if (fixable === false) break;
+                                      cost += fixable;
+                                    */
+                                }
                             }
-                            return {
-                                type: "ref",
-                                node,
-                                decl,
-                                mayThrow,
-                            };
-                        }
+                            return false;
+                        })) {
+                        break;
                     }
-                    break;
+                    return {
+                        type: "ref",
+                        node,
+                        decl: decls,
+                        mayThrow,
+                    };
+                }
                 case "VariableDeclarator": {
                     const decl = findDecl(node.id.type === "BinaryExpression" ? node.id.left : node.id);
                     if (decl) {
@@ -2496,8 +2538,10 @@ function buildPREGraph(state, func) {
                 }
                 case "CallExpression": {
                     liveDef(null, stmt);
-                    const [, results] = state.lookup(node.callee);
-                    const callees = results ? findCallees(results) : null;
+                    const [, results] = state.lookupNonlocal(node.callee);
+                    const callees = results
+                        ? findCallees(results)
+                        : findCalleesByNode(state, node.callee);
                     return { type: "mod", node, mayThrow, callees };
                 }
                 default:
@@ -2512,67 +2556,193 @@ function buildPREGraph(state, func) {
         }),
     };
 }
-function anticipatedDecls() {
-    return new Map();
-}
-function equalSet(a, b) {
-    if (a.size != b.size)
-        return false;
-    for (const item of a) {
-        if (!b.has(item))
-            return false;
-    }
-    return true;
-}
-function equalMap(a, b) {
-    if (a.size != b.size)
-        return false;
-    for (const [item, value] of a) {
-        if (b.get(item) !== value)
-            return false;
+class data_flow_DataflowQueue {
+    constructor() {
+        this.enqueued = new Set();
+        this.queue = new PriorityQueue((b, a) => (a.order || 0) - (b.order || 0));
     }
-    return true;
-}
-function anticipatedState(node, events) {
-    return { ant: events || new Set(), live: true, node, members: new Map() };
-}
-function cloneAnticipatedState(as) {
-    return {
-        ant: cloneSet(as.ant),
-        live: as.live,
-        node: as.node,
-        members: new Map(as.members),
-    };
-}
-function mergeAnticipatedState(ae, be) {
-    mergeSet(ae.ant, be.ant);
-    be.members.forEach((live, block) => ae.members.set(block, live));
-    if (be.live)
-        ae.live = true;
-}
-function cloneAnticipatedDecls(ad) {
-    const copy = anticipatedDecls();
-    for (const [k, v] of ad) {
-        if (!v.isIsolated) {
-            copy.set(k, cloneAnticipatedState(v));
+    enqueue(block) {
+        if (!this.enqueued.has(block)) {
+            this.enqueued.add(block);
+            this.queue.enq(block);
         }
     }
-    return copy;
-}
-function mergeAnticipatedDecls(a, b) {
-    for (const [k, v] of b) {
-        if (v.isIsolated)
-            continue;
-        const ae = a.get(k);
-        if (ae) {
-            mergeAnticipatedState(ae, v);
-        }
-        else {
-            a.set(k, cloneAnticipatedState(v));
-        }
+    dequeue() {
+        const block = this.queue.deq();
+        this.enqueued.delete(block);
+        return block;
+    }
+    empty() {
+        return this.queue.isEmpty();
     }
 }
-function equalStates(a, b) {
+
+;// CONCATENATED MODULE: ./src/pre.ts
+
+
+
+
+
+
+/**
+ * This implements a pseudo Partial Redundancy Elimination
+ * pass. It isn't quite like traditional PRE because we're
+ * aiming to minimize size, not dynamic instructions. So
+ * for us, its worthwhile to take something like:
+ *
+ * switch (x) {
+ *   case 1: foo(A.B); break;
+ *   case 2: foo(C); break;
+ *   case 3: bar(A.B); break;
+ * }
+ *
+ * and rewrite it as
+ *
+ * var tmp = A.B;
+ * switch (x) {
+ *   case 1: foo(tmp); break;
+ *   case 2: foo(C); break;
+ *   case 3: bar(tmp); break;
+ * }
+ *
+ * because even though A.B wasn't used on all paths where we
+ * inserted the temporary, we still reduced the code size.
+ */
+const logging = false;
+function logAntState(s, decl) {
+    const defs = Array.from(s.ant).reduce((defs, event) => {
+        if (event.type === "def" || event.type === "mod")
+            defs++;
+        return defs;
+    }, 0);
+    console.log(`  - ${declFullName(decl)}: ${candidateCost(s)} bytes, ${s.ant.size - defs} refs, ${defs} defs, ${s.live ? "" : "!"}live, ${s.isIsolated ? "" : "!"}isolated`);
+    console.log(`    - members: ${Array.from(s.members)
+        .map(([block, live]) => block.order + (live ? "t" : "f"))
+        .join(", ")}`);
+}
+function logAntDecls(antDecls) {
+    antDecls.forEach(logAntState);
+}
+function pre_sizeBasedPRE(state, func) {
+    if (!func.node.body)
+        return;
+    if (!state.config ||
+        !state.config.sizeBasedPRE ||
+        (typeof state.config.sizeBasedPRE === "string" &&
+            state.config.sizeBasedPRE !== func.fullName)) {
+        return;
+    }
+    const { graph: head, identifiers } = buildPREGraph(state, func);
+    const candidates = computeAttributes(state, head);
+    if (candidates) {
+        if (logging) {
+            console.log(`Found ${candidates.size} candidates in ${func.fullName}`);
+            logAntDecls(candidates);
+        }
+        const nodeMap = new Map();
+        const declMap = new Map();
+        const variableDecl = withLoc({
+            type: "VariableDeclaration",
+            declarations: [],
+            kind: "var",
+        }, func.node.body);
+        variableDecl.end = variableDecl.start;
+        variableDecl.loc.end = variableDecl.loc.start;
+        candidates.forEach((s, decl) => {
+            let name;
+            let i = 0;
+            do {
+                name = `pre_${declName(decl)}${i ? "_" + i : ""}`;
+                if (!identifiers.has(name)) {
+                    identifiers.add(name);
+                    break;
+                }
+                i++;
+            } while (true);
+            declMap.set(decl, name);
+            variableDecl.declarations.push(withLoc({
+                type: "VariableDeclarator",
+                id: withLoc({ type: "Identifier", name }, variableDecl),
+                kind: "var",
+            }, variableDecl));
+            s.ant.forEach((event) => {
+                const events = nodeMap.get(event.node);
+                if (!events) {
+                    nodeMap.set(event.node, [event]);
+                }
+                else {
+                    events.push(event);
+                }
+            });
+        });
+        applyReplacements(func.node, nodeMap, declMap);
+        func.node.body.body.unshift(variableDecl);
+    }
+}
+function buildPREGraph(state, func) {
+    return buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
+}
+function anticipatedDecls() {
+    return new Map();
+}
+function equalSet(a, b) {
+    if (a.size != b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+function equalMap(a, b) {
+    if (a.size != b.size)
+        return false;
+    for (const [item, value] of a) {
+        if (b.get(item) !== value)
+            return false;
+    }
+    return true;
+}
+function anticipatedState(node, events) {
+    return { ant: events || new Set(), live: true, node, members: new Map() };
+}
+function cloneAnticipatedState(as) {
+    return {
+        ant: cloneSet(as.ant),
+        live: as.live,
+        node: as.node,
+        members: new Map(as.members),
+    };
+}
+function mergeAnticipatedState(ae, be) {
+    mergeSet(ae.ant, be.ant);
+    be.members.forEach((live, block) => ae.members.set(block, live));
+    if (be.live)
+        ae.live = true;
+}
+function cloneAnticipatedDecls(ad) {
+    const copy = anticipatedDecls();
+    for (const [k, v] of ad) {
+        if (!v.isIsolated) {
+            copy.set(k, cloneAnticipatedState(v));
+        }
+    }
+    return copy;
+}
+function mergeAnticipatedDecls(a, b) {
+    for (const [k, v] of b) {
+        if (v.isIsolated)
+            continue;
+        const ae = a.get(k);
+        if (ae) {
+            mergeAnticipatedState(ae, v);
+        }
+        else {
+            a.set(k, cloneAnticipatedState(v));
+        }
+    }
+}
+function equalStates(a, b) {
     if (a.size !== b.size)
         return false;
     for (const [k, ae] of a) {
@@ -2667,26 +2837,18 @@ function computeAttributes(state, head) {
                 .join(", ")}`);
             if (block.events) {
                 block.events.forEach((event) => event.type !== "exn" &&
-                    console.log(`    ${event.type}: ${event.decl ? declFullName(event.decl) : "??"}`));
+                    console.log(`    ${event.type}: ${event.decl
+                        ? declFullName(event.decl)
+                        : event.node
+                            ? formatAst(event.node)
+                            : "??"}`));
             }
             console.log(`Succs: ${(block.succs || [])
                 .map((block) => block.order)
                 .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
         });
     }
-    const enqueued = new Set();
-    const queue = new PriorityQueue((b, a) => (a.order || 0) - (b.order || 0));
-    const enqueue = (block) => {
-        if (!enqueued.has(block)) {
-            enqueued.add(block);
-            queue.enq(block);
-        }
-    };
-    const dequeue = () => {
-        const block = queue.deq();
-        enqueued.delete(block);
-        return block;
-    };
+    const queue = new DataflowQueue();
     const blockStates = [];
     /*
       Algorithm
@@ -2720,9 +2882,9 @@ function computeAttributes(state, head) {
         }
         return result;
     };
-    order.forEach((block) => enqueue(block));
-    while (queue.size()) {
-        const top = dequeue();
+    order.forEach((block) => queue.enqueue(block));
+    while (!queue.empty()) {
+        const top = queue.dequeue();
         if (top.order === undefined) {
             throw new Error(`Unreachable block was visited!`);
         }
@@ -2761,13 +2923,13 @@ function computeAttributes(state, head) {
                         break;
                     }
                     case "mod": {
-                        curState.forEach((candidates, decl) => {
-                            if (decl.type === "VariableDeclarator" &&
+                        curState.forEach((candidates, decls) => {
+                            if (some(decls, (decl) => decl.type === "VariableDeclarator" &&
                                 decl.node.kind === "var" &&
                                 candidates.live &&
                                 (!event.callees ||
-                                    event.callees.some((callee) => functionMayModify(state, callee, decl)))) {
-                                candidates.ant.add(getMod(event, decl, candidates.node));
+                                    event.callees.some((callee) => functionMayModify(state, callee, decl))))) {
+                                candidates.ant.add(getMod(event, decls, candidates.node));
                                 candidates.live = false;
                             }
                         });
@@ -2819,7 +2981,7 @@ function computeAttributes(state, head) {
             logAntDecls(curState);
         }
         if (top.preds) {
-            top.preds.forEach((pred) => enqueue(pred));
+            top.preds.forEach((pred) => queue.enqueue(pred));
         }
     }
     const candidateDecls = anticipatedDecls();
@@ -3658,8 +3820,21 @@ function replacementLiteral(arg, value, type) {
     else if (type === "Double") {
         raw += "d";
     }
-    else if (type === "Float" && prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
-        raw += "f";
+    else if (type === "Float") {
+        if (prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
+            raw += "f";
+        }
+        else {
+            const match = raw.match(/^(-)?(\d*)\.(\d+)(e\d+)?/);
+            if (match && match[2].length + match[3].length > 9) {
+                for (let l = 9 - match[2].length; l > 0; l--) {
+                    const s = `${match[1] || ""}${match[2]}.${match[3].substring(0, l)}${match[4] || ""}`;
+                    if (value !== roundToFloat(parseFloat(s)))
+                        break;
+                    raw = s;
+                }
+            }
+        }
     }
     const { start, end, loc } = arg;
     return {
@@ -3747,6 +3922,20 @@ function shift_mod_types(left, right) {
     }
     return result;
 }
+function equalsFn(left, right) {
+    const lt = typeof left;
+    const rt = typeof right;
+    return lt === "string" || rt === "string"
+        ? // two string literals will compare unequal, becuase string
+            // equality is object equality.
+            false
+        : (lt === "number" || lt === "bigint") &&
+            (rt === "number" || rt === "bigint")
+            ? // numeric types are compared for value equality
+                left == right
+            : // otherwise types and values must match
+                left === right;
+}
 const operators = {
     "+": {
         typeFn: plus_types,
@@ -3798,14 +3987,11 @@ const operators = {
     },
     "==": {
         typeFn: () => ["Boolean", (v) => v],
-        valueFn: (left, right) => 
-        // two string literals will compare unequal, becuase string
-        // equality is object equality.
-        typeof left === "string" ? false : left === right,
+        valueFn: equalsFn,
     },
     "!=": {
         typeFn: () => ["Boolean", (v) => v],
-        valueFn: (left, right) => typeof left === "string" ? true : left !== right,
+        valueFn: (left, right) => !equalsFn(left, right),
     },
     "<=": {
         typeFn: common_arith_types,
@@ -4332,7 +4518,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 if (!state.currentFunction) {
                     throw new Error(`Finished function ${state.stack.slice(-1)[0].fullName}, but it was not marked current`);
                 }
-                state.currentFunction.info = state.currentFunction.next_info;
+                state.currentFunction.info = state.currentFunction.next_info || false;
                 delete state.currentFunction.next_info;
                 delete state.currentFunction;
                 break;
@@ -4987,31 +5173,6 @@ function add_resources_to_ast(state, ast, resources, manifestXML) {
         });
     });
 }
-function makeIdentifier(name, loc) {
-    return wrap({ type: "Identifier", name }, loc);
-}
-function makeMemberExpression(object, property) {
-    return wrap({
-        type: "MemberExpression",
-        object,
-        property,
-        computed: false,
-    }, object.loc && locRange(object.loc, property.loc));
-}
-function makeScopedName(dotted, l) {
-    const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
-    return dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
-        const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
-        if (!cur) {
-            cur = id;
-        }
-        else {
-            cur = makeMemberExpression(cur, id);
-        }
-        offset += next.length + 1;
-        return { cur, offset };
-    }, { cur: null, offset: 0 }).cur;
-}
 const drawableSkips = {
     x: { center: true, left: true, right: true, start: true },
     y: { center: true, top: true, bottom: true, start: true },
@@ -5051,10 +5212,8 @@ function visit_resource_refs(state, doc, e) {
         if (ast_hasProperty(skip, name)) {
             return;
         }
-        if (/^([\w_$]+\s*\.\s*)*[\w_$]+$/.test(name)) {
-            const dn = makeScopedName(name, loc);
-            if (dn)
-                result.push(dn);
+        if (/^([-\w_$]+\s*\.\s*)*[-\w_$]+$/.test(name)) {
+            result.push(makeScopedName(name, loc));
             return;
         }
         // We wrap the expression in parentheses, so adjust
@@ -5154,37 +5313,6 @@ function visit_resource_refs(state, doc, e) {
     });
     return result;
 }
-function wrap(node, loc) {
-    if (loc) {
-        node.loc = loc;
-        node.start = loc.start.offset;
-        node.end = loc.end.offset;
-    }
-    return node;
-}
-function locRange(start, end) {
-    return {
-        source: start.source || end.source,
-        start: start.start,
-        end: end.end,
-    };
-}
-function adjustLoc(loc, start = 1, end = -1) {
-    /* Attributes are quoted, so skip the quotes */
-    return {
-        source: loc.source,
-        start: {
-            offset: loc.start.offset + start,
-            line: loc.start.line,
-            column: loc.start.column + start,
-        },
-        end: {
-            offset: loc.end.offset + end,
-            line: loc.end.line,
-            column: loc.end.column + end,
-        },
-    };
-}
 function add_one_resource(state, doc, module, e) {
     let id;
     let func;
@@ -5196,7 +5324,20 @@ function add_one_resource(state, doc, module, e) {
                 wrap({
                     type: "VariableDeclarator",
                     kind: "var",
-                    id: makeIdentifier(id ? id.value.value : "*invalid*", loc),
+                    id: {
+                        type: "BinaryExpression",
+                        operator: "as",
+                        left: makeIdentifier(id ? id.value.value : "*invalid*", loc),
+                        right: {
+                            type: "TypeSpecList",
+                            ts: [
+                                {
+                                    type: "TypeSpecPart",
+                                    name: makeIdentifier("Symbol"),
+                                },
+                            ],
+                        },
+                    },
                     init,
                 }, e.loc),
             ],
@@ -5218,19 +5359,75 @@ function add_one_resource(state, doc, module, e) {
             loc: e.loc,
         };
     };
+    const layoutDecl = () => {
+        if (!id)
+            return null;
+        const loc = id.value.loc;
+        const items = init ? [varDecl()] : [];
+        return {
+            type: "FunctionDeclaration",
+            body: { type: "BlockStatement", body: items, loc: e.loc },
+            id: makeIdentifier(id.value.value, loc),
+            params: [
+                {
+                    type: "BinaryExpression",
+                    operator: "as",
+                    left: makeIdentifier("dc"),
+                    right: {
+                        type: "TypeSpecList",
+                        ts: [
+                            {
+                                type: "TypeSpecPart",
+                                name: makeScopedName("Graphics.Dc"),
+                            },
+                        ],
+                    },
+                },
+            ],
+            returnType: {
+                type: "UnaryExpression",
+                operator: " as",
+                prefix: true,
+                argument: {
+                    type: "TypeSpecList",
+                    ts: [
+                        {
+                            type: "TypeSpecPart",
+                            name: makeScopedName("$.Toybox.Lang.Array"),
+                            generics: [
+                                {
+                                    type: "TypeSpecList",
+                                    ts: [
+                                        {
+                                            type: "TypeSpecPart",
+                                            name: makeScopedName("$.Toybox.WatchUi.Drawable"),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+            loc: e.loc,
+        };
+    };
     switch (e.name) {
         case "font":
         case "string":
         case "jsonData":
         case "animation":
         case "bitmap":
-        case "layout":
         case "drawable-list":
         case "property":
         case "fitField":
             id = e.attr.id;
             func = varDecl;
             break;
+        case "layout":
+            id = e.attr.id;
+            func = layoutDecl;
+            break;
         case "menu":
             id = e.attr.id;
             func = () => classDecl("Ui.Menu");
@@ -5820,387 +6017,423 @@ function lookup(state, decls, node, name, maybeStack, nonlocal, ignoreImports) {
     }
     return [false, false];
 }
-function api_collectNamespaces(ast, stateIn) {
-    const state = (stateIn || {});
-    if (!state.nextExposed)
-        state.nextExposed = {};
-    if (!state.index)
-        state.index = {};
-    if (!state.stack) {
-        state.stack = [
-            {
-                type: "Program",
-                name: "$",
-                fullName: "$",
-                node: undefined,
-                attributes: 0,
-            },
-        ];
-    }
-    if (!state.lookupRules) {
-        const rules = state?.config?.compilerLookupRules || "DEFAULT";
-        if (rules !== "COMPILER1" && rules !== "COMPILER2") {
-            const match = state.sdk?.match(/-(\d+\.\d+\.\d+).(compiler2beta)?/i);
-            if (match && (match[2] || parseSdkVersion(match[1]) >= 4001006)) {
-                state.lookupRules = "COMPILER2";
-            }
-            else {
-                state.lookupRules = "COMPILER1";
-            }
-        }
-    }
-    state.removeNodeComments = (node, ast) => {
-        if (node.start && node.end && ast.comments && ast.comments.length) {
-            let low = 0, high = ast.comments.length;
-            while (high > low) {
-                const mid = (low + high) >> 1;
-                if ((ast.comments[mid].start || 0) < node.start) {
-                    low = mid + 1;
+function stateFuncs() {
+    let currentEnum = null;
+    return {
+        removeNodeComments(node, ast) {
+            if (node.start && node.end && ast.comments && ast.comments.length) {
+                let low = 0, high = ast.comments.length;
+                while (high > low) {
+                    const mid = (low + high) >> 1;
+                    if ((ast.comments[mid].start || 0) < node.start) {
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid;
+                    }
                 }
-                else {
-                    high = mid;
+                while (high < ast.comments.length &&
+                    (ast.comments[high].end || 0) < node.end) {
+                    high++;
+                }
+                if (high > low) {
+                    ast.comments.splice(low, high - low);
                 }
             }
-            while (high < ast.comments.length &&
-                (ast.comments[high].end || 0) < node.end) {
-                high++;
-            }
-            if (high > low) {
-                ast.comments.splice(low, high - low);
-            }
-        }
-    };
-    state.lookup = (node, name, stack) => lookup(state, state.inType ? "type_decls" : "decls", node, name, stack);
-    state.lookupNonlocal = (node, name, stack) => lookup(state, "decls", node, name, stack, true);
-    state.lookupValue = (node, name, stack) => lookup(state, "decls", node, name, stack);
-    state.lookupType = (node, name, stack) => lookup(state, "type_decls", node, name, stack);
-    state.stackClone = () => state.stack.map((elm) => elm.type === "ModuleDeclaration" || elm.type === "Program"
-        ? { ...elm }
-        : elm);
-    state.inType = 0;
-    state.traverse = (root) => ast_traverseAst(root, (node) => {
-        try {
-            if (state.shouldExclude && state.shouldExclude(node)) {
-                // don't visit any children, but do call post
-                return [];
-            }
-            switch (node.type) {
-                case "UnaryExpression":
-                    if (node.operator === ":" && !state.inType) {
-                        state.nextExposed[node.argument.name] = true;
-                    }
-                    break;
-                case "AttributeList":
-                    return [];
-                case "Program":
-                    if (state.stack.length != 1) {
-                        throw new Error("Unexpected stack length for Program node");
+        },
+        lookup(node, name, stack) {
+            return lookup(this, this.inType ? "type_decls" : "decls", node, name, stack);
+        },
+        lookupNonlocal(node, name, stack) {
+            return lookup(this, "decls", node, name, stack, true);
+        },
+        lookupValue(node, name, stack) {
+            return lookup(this, "decls", node, name, stack);
+        },
+        lookupType(node, name, stack) {
+            return lookup(this, "type_decls", node, name, stack);
+        },
+        stackClone() {
+            return this.stack.map((elm) => elm.type === "ModuleDeclaration" || elm.type === "Program"
+                ? { ...elm }
+                : elm);
+        },
+        traverse(root) {
+            return ast_traverseAst(root, (node) => {
+                try {
+                    if (this.shouldExclude && this.shouldExclude(node)) {
+                        // don't visit any children, but do call post
+                        return [];
                     }
-                    state.stack[0].node = node;
-                    break;
-                case "TypeSpecList":
-                case "TypeSpecPart":
-                    state.inType++;
-                    break;
-                case "ImportModule":
-                case "Using": {
-                    const [parent] = state.stack.slice(-1);
-                    if (!parent.usings) {
-                        parent.usings = {};
-                    }
-                    const name = (node.type === "Using" && node.as && node.as.name) ||
-                        (node.id.type === "Identifier"
-                            ? node.id.name
-                            : node.id.property.name);
-                    const using = { node };
-                    parent.usings[name] = using;
-                    if (node.type == "ImportModule") {
-                        if (!parent.imports) {
-                            parent.imports = [using];
+                    switch (node.type) {
+                        case "MemberExpression": {
+                            if (api_isLookupCandidate(node)) {
+                                return (this.pre && this.pre(node, this)) || ["object"];
+                            }
+                            break;
                         }
-                        else {
-                            const index = parent.imports.findIndex((using) => (using.node.id.type === "Identifier"
-                                ? using.node.id.name
-                                : using.node.id.property.name) === name);
-                            if (index >= 0)
-                                parent.imports.splice(index, 1);
-                            parent.imports.push(using);
+                        case "UnaryExpression":
+                            if (node.operator === ":" && !this.inType) {
+                                this.nextExposed[node.argument.name] = true;
+                            }
+                            break;
+                        case "AttributeList":
+                            return [];
+                        case "Program":
+                            if (this.stack.length != 1) {
+                                throw new Error("Unexpected stack length for Program node");
+                            }
+                            this.stack[0].node = node;
+                            break;
+                        case "TypeSpecList":
+                        case "TypeSpecPart":
+                            this.inType++;
+                            break;
+                        case "ImportModule":
+                        case "Using": {
+                            const [parent] = this.stack.slice(-1);
+                            if (!parent.usings) {
+                                parent.usings = {};
+                            }
+                            const name = (node.type === "Using" && node.as && node.as.name) ||
+                                (node.id.type === "Identifier"
+                                    ? node.id.name
+                                    : node.id.property.name);
+                            const using = { node };
+                            parent.usings[name] = using;
+                            if (node.type == "ImportModule") {
+                                if (!parent.imports) {
+                                    parent.imports = [using];
+                                }
+                                else {
+                                    const index = parent.imports.findIndex((using) => (using.node.id.type === "Identifier"
+                                        ? using.node.id.name
+                                        : using.node.id.property.name) === name);
+                                    if (index >= 0)
+                                        parent.imports.splice(index, 1);
+                                    parent.imports.push(using);
+                                }
+                            }
+                            break;
                         }
-                    }
-                    break;
-                }
-                case "CatchClause":
-                    if (node.param) {
-                        const [parent] = state.stack.slice(-1);
-                        if (!parent.decls)
-                            parent.decls = {};
-                        const id = node.param.type === "Identifier"
-                            ? node.param
-                            : node.param.left;
-                        state.stack.push({
-                            type: "BlockStatement",
-                            fullName: undefined,
-                            name: undefined,
-                            node: node.body,
-                            decls: { [id.name]: [id] },
-                            attributes: 0,
-                        });
-                    }
-                    break;
-                case "ForStatement":
-                    if (node.init && node.init.type === "VariableDeclaration") {
-                        state.stack.push({
-                            type: "BlockStatement",
-                            fullName: undefined,
-                            name: undefined,
-                            node: node,
-                            attributes: 0,
-                        });
-                    }
-                    break;
-                case "BlockStatement": {
-                    const [parent] = state.stack.slice(-1);
-                    if (parent.node === node ||
-                        (parent.type != "FunctionDeclaration" &&
-                            parent.type != "BlockStatement")) {
-                        break;
-                    }
-                    // fall through
-                }
-                case "ClassDeclaration":
-                case "FunctionDeclaration":
-                case "ModuleDeclaration": {
-                    const [parent] = state.stack.slice(-1);
-                    const name = "id" in node ? node.id && node.id.name : undefined;
-                    const fullName = state.stack
-                        .map((e) => e.name)
-                        .concat(name)
-                        .filter((e) => e != null)
-                        .join(".");
-                    const elm = {
-                        type: node.type,
-                        name,
-                        fullName,
-                        node,
-                        attributes: node.type === "BlockStatement"
-                            ? 0
-                            : stateNodeAttrs(node.attrs),
-                    };
-                    state.stack.push(elm);
-                    if (name) {
-                        if (!parent.decls)
-                            parent.decls = {};
-                        if (ast_hasProperty(parent.decls, name)) {
-                            const what = node.type == "ModuleDeclaration" ? "type" : "node";
-                            const e = parent.decls[name].find((d) => api_isStateNode(d) && d[what] == elm[what]);
-                            if (e != null) {
-                                e.node = node;
-                                state.stack.splice(-1, 1, e);
+                        case "CatchClause":
+                            if (node.param) {
+                                const [parent] = this.stack.slice(-1);
+                                if (!parent.decls)
+                                    parent.decls = {};
+                                const id = node.param.type === "Identifier"
+                                    ? node.param
+                                    : node.param.left;
+                                this.stack.push({
+                                    type: "BlockStatement",
+                                    fullName: undefined,
+                                    name: undefined,
+                                    node: node.body,
+                                    decls: { [id.name]: [id] },
+                                    attributes: 0,
+                                });
+                            }
+                            break;
+                        case "ForStatement":
+                            if (node.init && node.init.type === "VariableDeclaration") {
+                                this.stack.push({
+                                    type: "BlockStatement",
+                                    fullName: undefined,
+                                    name: undefined,
+                                    node: node,
+                                    attributes: 0,
+                                });
+                            }
+                            break;
+                        case "BlockStatement": {
+                            const [parent] = this.stack.slice(-1);
+                            if (parent.node === node ||
+                                (parent.type != "FunctionDeclaration" &&
+                                    parent.type != "BlockStatement")) {
                                 break;
                             }
+                            // fall through
                         }
-                        else {
-                            parent.decls[name] = [];
+                        case "ClassDeclaration":
+                        case "FunctionDeclaration":
+                        case "ModuleDeclaration": {
+                            const [parent] = this.stack.slice(-1);
+                            const name = "id" in node ? node.id && node.id.name : undefined;
+                            const fullName = this.stack
+                                .map((e) => e.name)
+                                .concat(name)
+                                .filter((e) => e != null)
+                                .join(".");
+                            const elm = {
+                                type: node.type,
+                                name,
+                                fullName,
+                                node,
+                                attributes: node.type === "BlockStatement"
+                                    ? 0
+                                    : stateNodeAttrs(node.attrs),
+                            };
+                            this.stack.push(elm);
+                            if (name) {
+                                if (!parent.decls)
+                                    parent.decls = {};
+                                if (ast_hasProperty(parent.decls, name)) {
+                                    const what = node.type == "ModuleDeclaration" ? "type" : "node";
+                                    const e = parent.decls[name].find((d) => api_isStateNode(d) && d[what] == elm[what]);
+                                    if (e != null) {
+                                        e.node = node;
+                                        this.stack.splice(-1, 1, e);
+                                        break;
+                                    }
+                                }
+                                else {
+                                    parent.decls[name] = [];
+                                }
+                                if (node.type === "FunctionDeclaration" &&
+                                    node.params &&
+                                    node.params.length) {
+                                    const decls = (elm.decls = {});
+                                    node.params.forEach((p) => (decls[api_variableDeclarationName(p)] = [p]));
+                                }
+                                parent.decls[name].push(elm);
+                                if (node.type == "ModuleDeclaration" ||
+                                    node.type == "ClassDeclaration") {
+                                    if (!parent.type_decls)
+                                        parent.type_decls = {};
+                                    if (!ast_hasProperty(parent.type_decls, name)) {
+                                        parent.type_decls[name] = [];
+                                    }
+                                    parent.type_decls[name].push(elm);
+                                }
+                                break;
+                            }
+                            break;
                         }
-                        if (node.type === "FunctionDeclaration" &&
-                            node.params &&
-                            node.params.length) {
-                            const decls = (elm.decls = {});
-                            node.params.forEach((p) => (decls[api_variableDeclarationName(p)] = [p]));
+                        // an EnumDeclaration doesn't create a scope, but
+                        // it does create a type (if it has a name)
+                        case "EnumDeclaration": {
+                            if (!node.id) {
+                                this.inType++;
+                                break;
+                            }
+                            const [parent] = this.stack.slice(-1);
+                            const name = (parent.fullName + "." + node.id.name).replace(/^\$\./, "");
+                            node.body.members.forEach((m) => (("init" in m ? m.init : m).enumType = name));
                         }
-                        parent.decls[name].push(elm);
-                        if (node.type == "ModuleDeclaration" ||
-                            node.type == "ClassDeclaration") {
+                        // fall through
+                        case "TypedefDeclaration": {
+                            this.inType++;
+                            const name = node.id.name;
+                            const [parent] = this.stack.slice(-1);
                             if (!parent.type_decls)
                                 parent.type_decls = {};
                             if (!ast_hasProperty(parent.type_decls, name)) {
                                 parent.type_decls[name] = [];
                             }
-                            parent.type_decls[name].push(elm);
+                            else if (parent.type_decls[name].find((n) => (api_isStateNode(n) ? n.node : n) === node)) {
+                                break;
+                            }
+                            const decl = {
+                                type: node.type,
+                                node,
+                                name,
+                                fullName: parent.fullName + "." + name,
+                                attributes: stateNodeAttrs(node.attrs),
+                                stack: this.stack.slice(),
+                            };
+                            parent.type_decls[name].push(decl);
+                            if (decl.type === "EnumDeclaration") {
+                                currentEnum = decl;
+                            }
+                            break;
+                        }
+                        case "VariableDeclaration": {
+                            const [parent] = this.stack.slice(-1);
+                            if (!parent.decls)
+                                parent.decls = {};
+                            const decls = parent.decls;
+                            const stack = this.stackClone();
+                            node.declarations.forEach((decl) => {
+                                const name = api_variableDeclarationName(decl.id);
+                                if (!ast_hasProperty(decls, name)) {
+                                    decls[name] = [];
+                                }
+                                else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
+                                    return;
+                                }
+                                decl.kind = node.kind;
+                                decls[name].push({
+                                    type: "VariableDeclarator",
+                                    node: decl,
+                                    name,
+                                    fullName: parent.fullName + "." + name,
+                                    stack,
+                                    attributes: stateNodeAttrs(node.attrs),
+                                });
+                                if (node.kind == "const") {
+                                    if (!ast_hasProperty(this.index, name)) {
+                                        this.index[name] = [];
+                                    }
+                                    (0,external_util_cjs_namespaceObject.pushUnique)(this.index[name], parent);
+                                }
+                            });
+                            break;
+                        }
+                        case "EnumStringBody": {
+                            if (this.inType !== 1) {
+                                throw new Error(`Expected inType to be 1 at EnumStringBody. Got ${this.inType}.`);
+                            }
+                            this.inType--;
+                            const [parent] = this.stack.slice(-1);
+                            const values = parent.decls || (parent.decls = {});
+                            let prev = -1;
+                            node.members.forEach((m, i) => {
+                                if (m.type == "Identifier") {
+                                    if (typeof prev === "bigint") {
+                                        prev += 1n;
+                                    }
+                                    else {
+                                        prev += 1;
+                                    }
+                                    m = node.members[i] = {
+                                        type: "EnumStringMember",
+                                        loc: m.loc,
+                                        start: m.start,
+                                        end: m.end,
+                                        id: m,
+                                        init: {
+                                            type: "Literal",
+                                            value: prev,
+                                            raw: prev.toString() +
+                                                (typeof prev === "bigint" ? "l" : ""),
+                                            enumType: m.enumType,
+                                            loc: m.loc,
+                                            start: m.start,
+                                            end: m.end,
+                                        },
+                                    };
+                                }
+                                const name = m.id.name;
+                                const init = getLiteralNode(m.init);
+                                if (!init) {
+                                    throw new Error("Unexpected enum initializer");
+                                }
+                                if (init != m.init) {
+                                    if (m.init.enumType) {
+                                        init.enumType = m.init.enumType;
+                                    }
+                                    m.init = init;
+                                }
+                                if (init.type == "Literal" &&
+                                    init.raw &&
+                                    prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(init.raw)) {
+                                    prev = init.value;
+                                }
+                                if (!ast_hasProperty(values, name)) {
+                                    values[name] = [];
+                                }
+                                if ((0,external_util_cjs_namespaceObject.pushUnique)(values[name], m) && currentEnum) {
+                                    if (!this.enumMap)
+                                        this.enumMap = new Map();
+                                    this.enumMap.set(m, currentEnum);
+                                }
+                                if (!ast_hasProperty(this.index, name)) {
+                                    this.index[name] = [];
+                                }
+                                (0,external_util_cjs_namespaceObject.pushUnique)(this.index[name], parent);
+                            });
+                            break;
                         }
                     }
-                    break;
+                    if (this.pre)
+                        return this.pre(node, this);
                 }
-                // an EnumDeclaration doesn't create a scope, but
-                // it does create a type (if it has a name)
-                case "EnumDeclaration": {
-                    if (!node.id) {
-                        state.inType++;
-                        break;
-                    }
-                    const [parent] = state.stack.slice(-1);
-                    const name = (parent.fullName + "." + node.id.name).replace(/^\$\./, "");
-                    node.body.members.forEach((m) => (("init" in m ? m.init : m).enumType = name));
+                catch (e) {
+                    handleException(this, node, e);
                 }
-                // fall through
-                case "TypedefDeclaration": {
-                    state.inType++;
-                    const name = node.id.name;
-                    const [parent] = state.stack.slice(-1);
-                    if (!parent.type_decls)
-                        parent.type_decls = {};
-                    if (!ast_hasProperty(parent.type_decls, name)) {
-                        parent.type_decls[name] = [];
-                    }
-                    else if (parent.type_decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == node)) {
-                        break;
+                return null;
+            }, (node) => {
+                try {
+                    let ret;
+                    if (this.shouldExclude && this.shouldExclude(node)) {
+                        // delete the node.
+                        ret = false;
                     }
-                    parent.type_decls[name].push(node.type === "EnumDeclaration"
-                        ? node
-                        : {
-                            type: "TypedefDeclaration",
-                            node,
-                            name,
-                            fullName: parent.fullName + "." + name,
-                            attributes: stateNodeAttrs(node.attrs),
-                        });
-                    break;
-                }
-                case "VariableDeclaration": {
-                    const [parent] = state.stack.slice(-1);
-                    if (!parent.decls)
-                        parent.decls = {};
-                    const decls = parent.decls;
-                    const stack = state.stackClone();
-                    node.declarations.forEach((decl) => {
-                        const name = api_variableDeclarationName(decl.id);
-                        if (!ast_hasProperty(decls, name)) {
-                            decls[name] = [];
-                        }
-                        else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
-                            return;
+                    else {
+                        const type = node.type;
+                        if (this.post)
+                            ret = this.post(node, this);
+                        switch (type) {
+                            case "EnumDeclaration":
+                                currentEnum = null;
+                            // fall through
+                            case "TypeSpecPart":
+                            case "TypeSpecList":
+                            case "TypedefDeclaration":
+                                this.inType--;
+                                break;
+                            case "EnumStringBody":
+                                this.inType++;
+                                break;
                         }
-                        decl.kind = node.kind;
-                        decls[name].push({
-                            type: "VariableDeclarator",
-                            node: decl,
-                            name,
-                            fullName: parent.fullName + "." + name,
-                            stack,
-                            attributes: stateNodeAttrs(node.attrs),
-                        });
-                        if (node.kind == "const") {
-                            if (!ast_hasProperty(state.index, name)) {
-                                state.index[name] = [];
+                        const [parent] = this.stack.slice(-1);
+                        if (parent.node === node ||
+                            // The pre function might cause node.body to be skipped,
+                            // so we need to check here, just in case.
+                            // (this actually happens with prettier-extenison-monkeyc's
+                            // findItemsByRange)
+                            (node.type === "CatchClause" && parent.node === node.body)) {
+                            delete parent.usings;
+                            delete parent.imports;
+                            if (node.type != "Program") {
+                                this.stack.pop();
                             }
-                            (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
                         }
-                    });
-                    break;
+                    }
+                    if (ret != null && node.loc && node.loc.source && this.fnMap) {
+                        const fnInfo = this.fnMap[node.loc.source];
+                        fnInfo && fnInfo.ast && this.removeNodeComments(node, fnInfo.ast);
+                    }
+                    return ret;
                 }
-                case "EnumStringBody": {
-                    if (state.inType !== 1) {
-                        throw new Error(`Expected inType to be 1 at EnumStringBody. Got ${state.inType}.`);
-                    }
-                    state.inType--;
-                    const [parent] = state.stack.slice(-1);
-                    const values = parent.decls || (parent.decls = {});
-                    let prev = -1;
-                    node.members.forEach((m, i) => {
-                        if (m.type == "Identifier") {
-                            if (typeof prev === "bigint") {
-                                prev += 1n;
-                            }
-                            else {
-                                prev += 1;
-                            }
-                            m = node.members[i] = {
-                                type: "EnumStringMember",
-                                loc: m.loc,
-                                start: m.start,
-                                end: m.end,
-                                id: m,
-                                init: {
-                                    type: "Literal",
-                                    value: prev,
-                                    raw: prev.toString() + (typeof prev === "bigint" ? "l" : ""),
-                                    enumType: m.enumType,
-                                    loc: m.loc,
-                                    start: m.start,
-                                    end: m.end,
-                                },
-                            };
-                        }
-                        const name = m.id.name;
-                        const init = getLiteralNode(m.init);
-                        if (!init) {
-                            throw new Error("Unexpected enum initializer");
-                        }
-                        if (init != m.init) {
-                            if (m.init.enumType) {
-                                init.enumType = m.init.enumType;
-                            }
-                            m.init = init;
-                        }
-                        if (init.type == "Literal" &&
-                            init.raw &&
-                            prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(init.raw)) {
-                            prev = init.value;
-                        }
-                        if (!ast_hasProperty(values, name)) {
-                            values[name] = [];
-                        }
-                        (0,external_util_cjs_namespaceObject.pushUnique)(values[name], m);
-                        if (!ast_hasProperty(state.index, name)) {
-                            state.index[name] = [];
-                        }
-                        (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
-                    });
-                    break;
+                catch (e) {
+                    handleException(this, node, e);
                 }
-            }
-            if (state.pre)
-                return state.pre(node, state);
-        }
-        catch (e) {
-            handleException(state, node, e);
-        }
-        return null;
-    }, (node) => {
-        try {
-            let ret;
-            if (state.shouldExclude && state.shouldExclude(node)) {
-                // delete the node.
-                ret = false;
+            });
+        },
+    };
+}
+function api_collectNamespaces(ast, stateIn) {
+    const state = (stateIn || {});
+    if (!state.nextExposed)
+        state.nextExposed = {};
+    if (!state.index)
+        state.index = {};
+    if (!state.stack) {
+        state.stack = [
+            {
+                type: "Program",
+                name: "$",
+                fullName: "$",
+                node: undefined,
+                attributes: 0,
+            },
+        ];
+    }
+    if (!state.lookupRules) {
+        const rules = state?.config?.compilerLookupRules || "DEFAULT";
+        if (rules !== "COMPILER1" && rules !== "COMPILER2") {
+            const match = state.sdk?.match(/-(\d+\.\d+\.\d+).(compiler2beta)?/i);
+            if (match && (match[2] || parseSdkVersion(match[1]) >= 4001006)) {
+                state.lookupRules = "COMPILER2";
             }
             else {
-                const type = node.type;
-                if (state.post)
-                    ret = state.post(node, state);
-                switch (type) {
-                    case "TypeSpecPart":
-                    case "TypeSpecList":
-                    case "TypedefDeclaration":
-                    case "EnumDeclaration":
-                        state.inType--;
-                        break;
-                    case "EnumStringBody":
-                        state.inType++;
-                        break;
-                }
-                const [parent] = state.stack.slice(-1);
-                if (parent.node === node ||
-                    // The pre function might cause node.body to be skipped,
-                    // so we need to check here, just in case.
-                    // (this actually happens with prettier-extenison-monkeyc's
-                    // findItemsByRange)
-                    (node.type === "CatchClause" && parent.node === node.body)) {
-                    delete parent.usings;
-                    delete parent.imports;
-                    if (node.type != "Program") {
-                        state.stack.pop();
-                    }
-                }
-            }
-            if (ret != null) {
-                state.removeNodeComments(node, ast);
+                state.lookupRules = "COMPILER1";
             }
-            return ret;
-        }
-        catch (e) {
-            handleException(state, node, e);
         }
-    });
+    }
+    Object.assign(state, stateFuncs());
+    state.inType = 0;
     state.traverse(ast);
     if (state.inType) {
         throw new Error(`inType was non-zero on exit: ${state.inType}`);
@@ -6223,8 +6456,11 @@ function api_formatAst(node, monkeyCSource = null, options = null) {
      * should be ignored.
      */
     switch (node.type) {
-        case "Program":
         case "BlockStatement":
+            if (node.body.length)
+                break;
+            return "{}";
+        case "Program":
         case "ExpressionStatement":
             break;
         default: {
@@ -6353,15 +6589,16 @@ function api_getApiFunctionInfo(func) {
         return invokeInfo;
     }
     if (!toyboxFnInfo.calledFuncs) {
-        toyboxFnInfo.modifiedDecls = new Set();
-        toyboxFnInfo.calledFuncs = new Set();
-        toyboxFnInfo.resolvedDecls = new Set();
+        return false;
     }
     return toyboxFnInfo;
 }
 function api_markInvokeClassMethod(func) {
     func.info = invokeInfo;
 }
+function api_isLocal(v) {
+    return v.stack[v.stack.length - 1]?.type === "BlockStatement";
+}
 
 })();