@markw65/monkeyc-optimizer 1.0.20 → 1.0.23

package/build/api.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {collectNamespaces,formatAst,getApiMapping,hasProperty,isStateNode,traverseAst,variableDeclarationName});
+0 && (module.exports = {collectNamespaces,findUsingForNode,formatAst,getApiMapping,hasProperty,isStateNode,sameLookupResult,traverseAst,variableDeclarationName,visitReferences});
 /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	// The require scope
@@ -53,12 +53,15 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   "collectNamespaces": () => (/* binding */ api_collectNamespaces),
-  "formatAst": () => (/* binding */ formatAst),
+  "findUsingForNode": () => (/* binding */ findUsingForNode),
+  "formatAst": () => (/* binding */ api_formatAst),
   "getApiMapping": () => (/* binding */ api_getApiMapping),
   "hasProperty": () => (/* binding */ api_hasProperty),
   "isStateNode": () => (/* binding */ api_isStateNode),
-  "traverseAst": () => (/* binding */ api_traverseAst),
-  "variableDeclarationName": () => (/* binding */ api_variableDeclarationName)
+  "sameLookupResult": () => (/* binding */ api_sameLookupResult),
+  "traverseAst": () => (/* reexport */ ast_traverseAst),
+  "variableDeclarationName": () => (/* binding */ api_variableDeclarationName),
+  "visitReferences": () => (/* reexport */ visitor_visitReferences)
 });
 
 ;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
@@ -68,10 +71,148 @@ var prettier_plugin_monkeyc_default = /*#__PURE__*/__webpack_require__.n(prettie
 const promises_namespaceObject = require("fs/promises");
 ;// CONCATENATED MODULE: external "prettier"
 const external_prettier_namespaceObject = require("prettier");
+;// CONCATENATED MODULE: ./src/ast.ts
+/*
+ * This ensures that mctreeTypeInfo has every key of MCTreeTypeInfo,
+ * and that the corresponding arrays contain every element of the
+ * corresponding type.
+ *
+ * ie, any time mctree.Node changes, we'll get errors here if
+ * mctreeTypeInfo needs updating.
+ *
+ */
+function _check(x) {
+    const y = x;
+    x = y;
+}
+const mctreeTypeInfo = {
+    ArrayExpression: ["elements"],
+    AssignmentExpression: ["left", "right"],
+    AttributeList: ["attributes"],
+    Attributes: ["elements"],
+    BinaryExpression: ["left", "right"],
+    Block: [],
+    BlockStatement: ["body", "innerComments"],
+    BreakStatement: [],
+    CallExpression: ["callee", "arguments"],
+    CatchClause: ["param", "body"],
+    CatchClauses: ["catches"],
+    ClassBody: ["body"],
+    ClassDeclaration: ["attrs", "id", "superClass", "body"],
+    ClassElement: ["item"],
+    ConditionalExpression: ["test", "consequent", "alternate"],
+    ContinueStatement: [],
+    DoWhileStatement: ["body", "test"],
+    EnumDeclaration: ["attrs", "id", "body"],
+    EnumStringBody: ["members"],
+    EnumStringMember: ["id", "init"],
+    ExpressionStatement: ["expression"],
+    ForStatement: ["init", "test", "body", "update"],
+    FunctionDeclaration: ["attrs", "id", "params", "body"],
+    Identifier: [],
+    IfStatement: ["test", "consequent", "alternate"],
+    ImportModule: ["id"],
+    InstanceOfCase: ["id"],
+    Line: [],
+    Literal: [],
+    LogicalExpression: ["left", "right"],
+    MemberExpression: ["object", "property"],
+    MethodDefinition: ["params", "returnType"],
+    ModuleDeclaration: ["attrs", "id", "body"],
+    MultiLine: [],
+    NewExpression: ["callee", "arguments"],
+    ObjectExpression: ["properties"],
+    ParenthesizedExpression: ["expression"],
+    Program: ["body", "comments"],
+    Property: ["key", "value"],
+    ReturnStatement: ["argument"],
+    SequenceExpression: ["expressions"],
+    SizedArrayExpression: ["size", "ts"],
+    SwitchCase: ["test", "consequent"],
+    SwitchStatement: ["discriminant", "cases"],
+    ThisExpression: [],
+    ThrowStatement: ["argument"],
+    TryStatement: ["block", "handler", "finalizer"],
+    TypedefDeclaration: ["attrs", "id", "ts"],
+    TypeSpecList: ["ts"],
+    TypeSpecPart: ["body", "callspec", "generics"],
+    UnaryExpression: ["argument"],
+    UpdateExpression: ["argument"],
+    Using: ["id", "as"],
+    VariableDeclaration: ["attrs", "declarations"],
+    VariableDeclarator: ["id", "init"],
+    WhileStatement: ["test", "body"],
+};
+function isMCTreeNode(node) {
+    return node ? typeof node === "object" && "type" in node : false;
+}
+/*
+ * Traverse the ast rooted at node, calling pre before
+ * visiting each node, and post after.
+ *
+ *  - if pre returns false, the node is not traversed, and
+ *    post is not called;
+ *  - if pre returns a list of child nodes, only those will
+ *    be traversed
+ *  - otherwise all child nodes are traversed
+ *
+ *  - if post returns false, the node it was called on is
+ *    removed.
+ */
+function ast_traverseAst(node, pre, post) {
+    const nodes = pre && pre(node);
+    if (nodes === false)
+        return;
+    if (!mctreeTypeInfo[node.type]) {
+        throw new Error("what?");
+    }
+    for (const key of nodes || mctreeTypeInfo[node.type]) {
+        const value = node[key];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            const values = value;
+            const deletions = values.reduce((state, obj, i) => {
+                if (isMCTreeNode(obj)) {
+                    const repl = ast_traverseAst(obj, pre, post);
+                    if (repl === false) {
+                        if (!state)
+                            state = {};
+                        state[i] = true;
+                    }
+                    else if (repl != null) {
+                        if (!state)
+                            state = {};
+                        values[i] = repl;
+                    }
+                }
+                return state;
+            }, null);
+            if (deletions) {
+                values.splice(0, values.length, ...values.filter((obj, i) => deletions[i] !== true).flat(1));
+            }
+        }
+        else if (isMCTreeNode(value)) {
+            const repl = ast_traverseAst(value, pre, post);
+            if (repl === false) {
+                delete node[key];
+            }
+            else if (repl != null) {
+                if (Array.isArray(repl)) {
+                    throw new Error("Array returned by traverseAst in Node context");
+                }
+                node[key] = repl;
+            }
+        }
+    }
+    return post && post(node);
+}
+
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
+
 function variable_renamer_renameVariable(state, locals, declName) {
     const map = locals.map;
     if (!hasProperty(map, declName))
@@ -128,27 +269,37 @@ function variable_renamer_renameVariable(state, locals, declName) {
 ;// CONCATENATED MODULE: ./src/inliner.ts
 
 
+
 function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
     const getSafety = (decl) => {
-        // enums are constant, they cant change
-        if (decl.type === "EnumStringMember")
-            return true;
-        if (decl.type === "VariableDeclarator") {
-            // constants also can't change
-            if (decl.node.kind === "const")
+        switch (decl.type) {
+            // enums are constant, they cant change
+            case "EnumStringMember":
                 return true;
-            // 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])
-                    return false;
-                if (state.stack[i].type === "FunctionDeclaration")
+            case "VariableDeclarator": {
+                // constants also can't change
+                if (decl.node.kind === "const")
                     return true;
+                // 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])
+                        return false;
+                    if (state.stack[i].type === "FunctionDeclaration")
+                        return true;
+                }
             }
+            case "Identifier":
+            case "BinaryExpression":
+                // This is a parameter of the calling function.
+                // It also can't be changed during the execution
+                // of the inlined function
+                return true;
+            default:
+                return null;
         }
-        return null;
     };
     const safeArgs = [];
     let allSafe = true;
@@ -160,11 +311,13 @@ function getArgSafety(state, func, args, requireAll) {
             case "Identifier":
             case "MemberExpression": {
                 const [, results] = state.lookup(arg);
-                if (!results || results.length !== 1) {
+                if (!results ||
+                    results.length !== 1 ||
+                    results[0].results.length !== 1) {
                     safeArgs.push(null);
                     return !requireAll;
                 }
-                const safety = getSafety(results[0]);
+                const safety = getSafety(results[0].results[0]);
                 safeArgs.push(safety);
                 if (!safety) {
                     allSafe = false;
@@ -184,25 +337,12 @@ function getArgSafety(state, func, args, requireAll) {
     if (allSafe && requireAll)
         return true;
     let callSeen = false;
-    let ok = true;
     const params = Object.fromEntries(func.node.params.map((param, i) => [variableDeclarationName(param), i]));
-    const getLoc = (node) => (Array.isArray(node) ? node[0].start : node.start) || 0;
     // look for uses of "unsafe" args that occur after a call.
     // use post to do the checking, because arguments are evaluated
     // prior to the call, so eg "return f(x.y);" is fine, but
     // "return f()+x.y" is not.
-    //
-    // We also have to use a "pre" to ensure that child nodes are
-    // visited in source order (otherwise we could visit x.y before f()
-    // in the above example)
-    traverseAst(func.node.body, (node) => {
-        return Object.entries(node)
-            .filter((kv) => Array.isArray(kv[1])
-            ? kv[1].length !== 0 && hasProperty(kv[1][0], "type")
-            : hasProperty(kv[1], "type"))
-            .sort(([, a], [, b]) => getLoc(a) - getLoc(b))
-            .map(([key]) => key);
-    }, (node) => {
+    traverseAst(func.node.body, null, (node) => {
         switch (node.type) {
             case "AssignmentExpression":
             case "UpdateExpression": {
@@ -256,27 +396,23 @@ function inliningLooksUseful(func, node) {
     }
     return false;
 }
-var InlineStatus;
-(function (InlineStatus) {
-    InlineStatus[InlineStatus["Never"] = 0] = "Never";
-    InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
-    InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
-})(InlineStatus || (InlineStatus = {}));
 function inlineRequested(state, func) {
     const excludeAnnotations = (func.node.loc?.source &&
         state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
         {};
     if (func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+        func.node.attrs.attributes &&
+        func.node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" &&
             (attr.argument.name === "inline" ||
                 (attr.argument.name.startsWith("inline_") &&
-                    hasProperty(excludeAnnotations, attr.argument.name.substring(7)))))) {
+                    !hasProperty(excludeAnnotations, attr.argument.name.substring(7)))))) {
         return true;
     }
     return false;
 }
 function inliner_shouldInline(state, func, call, context) {
+    if (state.inlining)
+        return false;
     let autoInline = false;
     let inlineAsExpression = false;
     const args = call.arguments;
@@ -309,6 +445,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     let failed = false;
     const pre = state.pre;
     const post = state.post;
+    state.inlining = true;
     try {
         state.pre = (node) => {
             if (failed)
@@ -354,7 +491,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
         };
         state.post = (node) => {
             if (failed)
-                return null;
+                return post(node, state);
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -371,12 +508,13 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     if (!replacement) {
                         failed = true;
                         inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
-                        return null;
+                        return post(node, state);
                     }
                     break;
                 }
             }
-            return post(replacement || node, state) || replacement;
+            const ret = post(replacement || node, state);
+            return ret === false || ret ? ret : replacement;
         };
         let ret = state.traverse(root);
         if (failed) {
@@ -395,6 +533,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     finally {
         state.pre = pre;
         state.post = post;
+        delete state.inlining;
     }
 }
 function inliner_unused(expression, top) {
@@ -436,13 +575,13 @@ function inliner_unused(expression, top) {
             },
         ];
 }
-function diagnostic(state, loc, message) {
+function inliner_diagnostic(state, loc, message, type = "INFO") {
     if (!loc || !loc.source)
         return;
     const source = loc.source;
     if (!state.diagnostics)
         state.diagnostics = {};
-    if (!hasProperty(state.diagnostics, source)) {
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.diagnostics, source)) {
         if (!message)
             return;
         state.diagnostics[source] = [];
@@ -452,7 +591,7 @@ function diagnostic(state, loc, message) {
     if (message) {
         if (index < 0)
             index = diags.length;
-        diags[index] = { type: "INFO", loc, message };
+        diags[index] = { type, loc, message };
     }
     else if (index >= 0) {
         diags.splice(index, 1);
@@ -460,7 +599,7 @@ function diagnostic(state, loc, message) {
 }
 function inlineDiagnostic(state, func, call, message) {
     if (inlineRequested(state, func)) {
-        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+        inliner_diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
     }
 }
 function inlineWithArgs(state, func, call, context) {
@@ -508,7 +647,7 @@ function inlineWithArgs(state, func, call, context) {
     if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
         return null;
     }
-    diagnostic(state, call.loc, null);
+    inliner_diagnostic(state, call.loc, null);
     if (context.type !== "ReturnStatement" && retStmtCount) {
         const last = body.body[body.body.length - 1];
         if (last.type != "ReturnStatement") {
@@ -571,23 +710,25 @@ function fixNodeScope(state, lookupNode, nodeStack) {
     // With a bit more work, we could find the guaranteed shortest
     // reference, and then use this to optimize *all* symbols, not
     // just fix inlined ones.
-    if (current &&
-        current.length === original.length &&
-        current.every((item, index) => item == original[index])) {
+    if (current && sameLookupResult(original, current)) {
         return lookupNode;
     }
     const node = lookupNode.type === "Identifier"
         ? lookupNode
         : lookupNode.property;
-    if (original.length === 1 && original[0].type === "EnumStringMember") {
-        return applyTypeIfNeeded(original[0].init);
+    if (original.length === 1 &&
+        original[0].results.length === 1 &&
+        original[0].results[0].type === "EnumStringMember") {
+        return applyTypeIfNeeded(original[0].results[0].init);
     }
-    const prefixes = original.map((sn) => {
+    const prefixes = original
+        .map((lookupDef) => lookupDef.results.map((sn) => {
         if (isStateNode(sn) && sn.fullName) {
             return sn.fullName;
         }
         return "";
-    });
+    }))
+        .flat();
     if (prefixes.length &&
         prefixes[0].startsWith("$.") &&
         prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
@@ -597,9 +738,7 @@ function fixNodeScope(state, lookupNode, nodeStack) {
             if (found)
                 return current;
             const [, results] = state.lookup(current);
-            if (results &&
-                results.length === original.length &&
-                results.every((result, i) => result === original[i])) {
+            if (results && sameLookupResult(original, results)) {
                 found = true;
                 return current;
             }
@@ -641,6 +780,99 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 
 ;// CONCATENATED MODULE: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
+;// CONCATENATED MODULE: ./src/visitor.ts
+
+function visitor_visitReferences(state, ast, name, defn, callback) {
+    const checkResults = ([name, results], node) => {
+        if (name && results) {
+            if (!defn || (0,external_api_cjs_namespaceObject.sameLookupResult)(results, defn)) {
+                if (callback(node, results, false) === false) {
+                    return [];
+                }
+            }
+        }
+        else if (defn === false) {
+            if (callback(node, [], results === null) === false) {
+                return [];
+            }
+        }
+        return null;
+    };
+    state.pre = (node) => {
+        switch (node.type) {
+            case "AttributeList":
+                return [];
+            case "UnaryExpression":
+                // a bare symbol isn't a reference
+                if (node.operator === ":")
+                    return [];
+                break;
+            case "BinaryExpression":
+                /*
+                 * `expr has :symbol` can be treated as a reference
+                 * to expr.symbol.
+                 */
+                if (node.operator === "has") {
+                    if (node.right.type === "UnaryExpression" &&
+                        node.right.operator === ":") {
+                        if (!name || node.right.argument.name === name) {
+                            return checkResults(state.lookup({
+                                type: "MemberExpression",
+                                object: node.left,
+                                property: node.right.argument,
+                                computed: false,
+                            }), node.right.argument);
+                        }
+                    }
+                }
+                break;
+            case "CallExpression":
+                // A call expression whose callee is an identifier is looked
+                // up as a non-local. ie even if there's a same named local,
+                // it will be ignored, and the lookup will start as if the
+                // call had been written self.foo() rather than foo().
+                if (node.callee.type === "Identifier") {
+                    if (!name || node.callee.name === name) {
+                        /* ignore return value */
+                        checkResults(state.lookupNonlocal(node.callee), node.callee);
+                    }
+                    return ["arguments"];
+                }
+                break;
+            case "Identifier":
+                if (!name || node.name === name) {
+                    return checkResults(state.lookup(node), node);
+                }
+                break;
+            case "MemberExpression":
+                if (!node.computed && node.property.type === "Identifier") {
+                    if (!name || node.property.name === name) {
+                        return checkResults(state.lookup(node), node) || ["object"];
+                    }
+                    return ["object"];
+                }
+                break;
+            case "MethodDefinition": {
+                if (!state.inType) {
+                    throw new Error("Method definition outside of type!");
+                }
+                if (node.params) {
+                    node.params.forEach((param) => {
+                        if (param.type == "BinaryExpression") {
+                            state.traverse(param.right);
+                            state.inType = true;
+                        }
+                    });
+                }
+                return ["returnType"];
+            }
+        }
+        return null;
+    };
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
+    delete state.pre;
+}
+
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
@@ -648,43 +880,25 @@ const external_util_cjs_namespaceObject = require("./util.cjs");
 
 
 
-function processImports(allImports, lookup) {
-    allImports.forEach(({ node, stack }) => {
-        const [name, module] = lookup(node.id, ("as" in node && node.as && node.as.name) || null, stack);
-        if (name && module) {
-            const [parent] = stack.slice(-1);
-            if (!parent.decls)
-                parent.decls = {};
-            const decls = parent.decls;
-            if (!hasProperty(decls, name))
-                decls[name] = [];
-            module.forEach((m) => {
-                if (isStateNode(m) && m.type == "ModuleDeclaration") {
-                    pushUnique(decls[name], m);
-                    if (!parent.type_decls)
-                        parent.type_decls = {};
-                    const tdecls = parent.type_decls;
-                    if (!hasProperty(tdecls, name))
-                        tdecls[name] = [];
-                    pushUnique(tdecls[name], m);
-                    if (node.type == "ImportModule" && m.type_decls) {
-                        Object.entries(m.type_decls).forEach(([name, decls]) => {
-                            if (!hasProperty(tdecls, name))
-                                tdecls[name] = [];
-                            decls.forEach((decl) => pushUnique(tdecls[name], decl));
-                        });
-                    }
-                }
-            });
-        }
-    });
-}
+
+
 function collectClassInfo(state) {
+    const toybox = state.stack[0].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") {
+            // nested classes don't get access to their contained
+            // context. Put them in the global scope instead.
+            elm.stack = elm.stack.slice(0, 1);
+        }
         if (elm.node.superClass) {
-            const [name, classes] = state.lookup(elm.node.superClass, null, elm.stack);
-            const superClass = classes &&
-                classes.filter((c) => isStateNode(c) && c.type === "ClassDeclaration");
+            const [name, lookupDefns] = state.lookup(elm.node.superClass, null, elm.stack);
+            const superClass = lookupDefns &&
+                lookupDefns
+                    .map((lookupDefn) => lookupDefn.results)
+                    .flat()
+                    .filter((c) => isStateNode(c) && c.type === "ClassDeclaration");
             // set it "true" if there is a superClass, but we can't find it.
             elm.superClass = superClass && superClass.length ? superClass : true;
             if (name && elm.superClass !== true) {
@@ -716,6 +930,9 @@ function collectClassInfo(state) {
                 elm.decls[name] = elm.superClass;
             }
         }
+        else if (elm !== object[0]) {
+            elm.superClass = object;
+        }
     });
     const markOverrides = (cls, scls) => {
         if (scls === true)
@@ -746,7 +963,9 @@ function getFileSources(fnMap) {
             fs
                 .readFile(name)
                 .then((data) => (value.monkeyCSource = data.toString().replace(/\r\n/g, "\n"))));
-    })).then(() => { });
+    })).then(() => {
+        return;
+    });
 }
 function getFileASTs(fnMap) {
     return getFileSources(fnMap).then(() => Object.entries(fnMap).reduce((ok, [name, value]) => {
@@ -769,22 +988,23 @@ function getFileASTs(fnMap) {
         return ok;
     }, true));
 }
-async function analyze(fnMap) {
+async function analyze(fnMap, barrelList, config) {
     let hasTests = false;
-    const allImports = [];
+    let markApi = true;
     const preState = {
         fnMap,
+        config,
         allFunctions: [],
         allClasses: [],
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
-                "attrs" in node.attrs &&
-                node.attrs.attrs &&
+                "attributes" in node.attrs &&
+                node.attrs.attributes &&
                 node.loc?.source) {
                 const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
                 if (excludeAnnotations) {
-                    return node.attrs.attrs.reduce((drop, attr) => {
+                    return node.attrs.attributes.elements.reduce((drop, attr) => {
                         if (attr.type != "UnaryExpression")
                             return drop;
                         if (attr.argument.type != "Identifier")
@@ -801,45 +1021,38 @@ async function analyze(fnMap) {
             }
             return false;
         },
-        post(node, state) {
+        pre(node, state) {
             switch (node.type) {
                 case "FunctionDeclaration":
+                    if (markApi) {
+                        node.body = null;
+                        break;
+                    }
+                // falls through
+                case "ModuleDeclaration":
                 case "ClassDeclaration": {
                     const [scope] = state.stack.slice(-1);
-                    const stack = state.stack.slice(0, -1);
-                    scope.stack = stack;
+                    scope.stack = state.stackClone().slice(0, -1);
                     if (scope.type == "FunctionDeclaration") {
+                        scope.isStatic =
+                            scope.stack.slice(-1)[0].type !== "ClassDeclaration" ||
+                                (scope.node.attrs &&
+                                    scope.node.attrs.access &&
+                                    scope.node.attrs.access.includes("static"));
                         state.allFunctions.push(scope);
                     }
-                    else {
+                    else if (scope.type === "ClassDeclaration") {
                         state.allClasses.push(scope);
                     }
-                    return null;
+                    break;
                 }
-                case "Using":
-                case "ImportModule":
-                    allImports.push({ node, stack: state.stack.slice() });
-                    return null;
-                default:
-                    return null;
             }
+            return null;
         },
     };
-    await getApiMapping(preState);
+    await getApiMapping(preState, barrelList);
+    markApi = false;
     const state = preState;
-    // Mark all functions from api.mir as "special" by
-    // setting their bodies to null. In api.mir, they're
-    // all empty, which makes it look like they're
-    // do-nothing functions.
-    const markApi = (node) => {
-        if (node.type == "FunctionDeclaration") {
-            node.node.body = null;
-        }
-        if (isStateNode(node) && node.decls) {
-            Object.values(node.decls).forEach((v) => v.forEach(markApi));
-        }
-    };
-    markApi(state.stack[0]);
     await getFileASTs(fnMap);
     Object.entries(fnMap).forEach(([name, value]) => {
         const { ast, parserError } = value;
@@ -852,8 +1065,28 @@ async function analyze(fnMap) {
     });
     delete state.shouldExclude;
     delete state.post;
-    processImports(allImports, state.lookup);
     collectClassInfo(state);
+    const diagnosticType = config?.checkInvalidSymbols !== "OFF"
+        ? config?.checkInvalidSymbols || "WARNING"
+        : null;
+    if (diagnosticType &&
+        !config?.compilerOptions?.includes("--Eno-invalid-symbol")) {
+        const checkTypes = config?.typeCheckLevel && config.typeCheckLevel !== "Off";
+        Object.entries(fnMap).forEach(([, v]) => {
+            visitReferences(state, v.ast, null, false, (node, results, error) => {
+                if (!error)
+                    return undefined;
+                const nodeStr = formatAst(node);
+                if (state.inType) {
+                    if (!checkTypes || nodeStr.match(/^Void|Null$/)) {
+                        return undefined;
+                    }
+                }
+                diagnostic(state, node.loc, `Undefined symbol ${nodeStr}`, diagnosticType);
+                return false;
+            });
+        });
+    }
     return state;
 }
 function compareLiteralLike(a, b) {
@@ -863,11 +1096,11 @@ function compareLiteralLike(a, b) {
         b = b.left;
     return a.type === "Literal" && b.type === "Literal" && a.value === b.value;
 }
-function getLiteralFromDecls(decls) {
-    if (!decls.length)
+function getLiteralFromDecls(lookupDefns) {
+    if (!lookupDefns.length)
         return null;
     let result = null;
-    if (decls.every((d) => {
+    if (lookupDefns.every((lookupDefn) => lookupDefn.results.every((d) => {
         if (d.type === "EnumStringMember" ||
             (d.type === "VariableDeclarator" && d.node.kind === "const")) {
             const init = getLiteralNode(d.type === "EnumStringMember" ? d.init : d.node.init);
@@ -882,7 +1115,7 @@ function getLiteralFromDecls(decls) {
             }
         }
         return false;
-    })) {
+    }))) {
         return result;
     }
     return null;
@@ -1093,14 +1326,23 @@ function markFunctionCalled(state, func) {
     }
     pushUnique(state.calledFunctions[func.id.name], func);
 }
-async function optimizeMonkeyC(fnMap) {
+async function optimizeMonkeyC(fnMap, barrelList, config) {
     const state = {
-        ...(await analyze(fnMap)),
+        ...(await analyze(fnMap, barrelList, config)),
         localsStack: [{}],
         exposed: {},
         calledFunctions: {},
     };
-    const replace = (node, obj) => {
+    const replace = (node, old) => {
+        if (node === false || node === null)
+            return node;
+        const rep = state.traverse(node);
+        if (rep === false || Array.isArray(rep))
+            return rep;
+        return { ...(rep || node), loc: old.loc, start: old.start, end: old.end };
+    };
+    const inPlaceReplacement = (node, obj) => {
+        const { start, end, loc } = node;
         for (const k of Object.keys(node)) {
             delete node[k];
         }
@@ -1108,13 +1350,16 @@ async function optimizeMonkeyC(fnMap) {
             obj = {
                 type: "BinaryExpression",
                 operator: "as",
-                left: obj,
+                left: { ...obj, start, end, loc },
                 right: { type: "TypeSpecList", ts: [obj.enumType] },
             };
         }
         for (const [k, v] of Object.entries(obj)) {
             node[k] = v;
         }
+        node.loc = loc;
+        node.start = start;
+        node.end = end;
     };
     const lookupAndReplace = (node) => {
         const [, objects] = state.lookup(node);
@@ -1125,7 +1370,7 @@ async function optimizeMonkeyC(fnMap) {
         if (!obj) {
             return false;
         }
-        replace(node, obj);
+        inPlaceReplacement(node, obj);
         return true;
     };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
@@ -1141,8 +1386,8 @@ async function optimizeMonkeyC(fnMap) {
         if (hasProperty(state.exposed, func.id.name))
             return true;
         if (func.attrs &&
-            func.attrs.attrs &&
-            func.attrs.attrs.some((attr) => {
+            func.attrs.attributes &&
+            func.attrs.attributes.elements.some((attr) => {
                 if (attr.type != "UnaryExpression")
                     return false;
                 if (attr.argument.type != "Identifier")
@@ -1172,7 +1417,7 @@ async function optimizeMonkeyC(fnMap) {
             case "ConditionalExpression":
             case "IfStatement":
             case "DoWhileStatement":
-            case "WhileStatement":
+            case "WhileStatement": {
                 const test = (state.traverse(node.test) ||
                     node.test);
                 const [value, type] = getNodeValue(test);
@@ -1204,6 +1449,7 @@ async function optimizeMonkeyC(fnMap) {
                     }
                 }
                 return null;
+            }
             case "EnumDeclaration":
                 return false;
             case "ForStatement": {
@@ -1233,6 +1479,37 @@ async function optimizeMonkeyC(fnMap) {
                 }
                 return ["init"];
             }
+            case "CatchClause":
+                if (node.param) {
+                    state.localsStack.push({ node, map: { ...(topLocals().map || {}) } });
+                    const locals = topLocals();
+                    const map = locals.map;
+                    const declName = variableDeclarationName(node.param);
+                    const name = renameVariable(state, locals, declName);
+                    if (name) {
+                        if (node.param.type === "Identifier") {
+                            node.param.name = name;
+                        }
+                        else {
+                            node.param.left.name = name;
+                        }
+                    }
+                    else {
+                        map[declName] = true;
+                    }
+                    return ["body"];
+                }
+                break;
+            case "BinaryExpression":
+                if (node.operator === "has") {
+                    if (node.right.type === "UnaryExpression" &&
+                        node.right.operator === ":") {
+                        // Using `expr has :symbol` doesn't "expose"
+                        // symbol. So skip the right operand.
+                        return ["left"];
+                    }
+                }
+                break;
             case "UnaryExpression":
                 if (node.operator == ":") {
                     // If we produce a Symbol, for a given name,
@@ -1315,8 +1592,7 @@ async function optimizeMonkeyC(fnMap) {
         }
         const opt = optimizeNode(node);
         if (opt) {
-            replace(node, opt);
-            return null;
+            return replace(opt, node);
         }
         switch (node.type) {
             case "ConditionalExpression":
@@ -1326,7 +1602,7 @@ async function optimizeMonkeyC(fnMap) {
                     const rep = node.test.value ? node.consequent : node.alternate;
                     if (!rep)
                         return false;
-                    replace(node, rep);
+                    return replace(rep, rep);
                 }
                 break;
             case "WhileStatement":
@@ -1341,15 +1617,11 @@ async function optimizeMonkeyC(fnMap) {
                 break;
             case "ReturnStatement":
                 if (node.argument && node.argument.type === "CallExpression") {
-                    return optimizeCall(state, node.argument, node);
+                    return replace(optimizeCall(state, node.argument, node), node.argument);
                 }
                 break;
             case "CallExpression": {
-                const ret = optimizeCall(state, node, null);
-                if (ret) {
-                    replace(node, ret);
-                }
-                break;
+                return replace(optimizeCall(state, node, null), node);
             }
             case "AssignmentExpression":
                 if (node.operator === "=" &&
@@ -1361,7 +1633,7 @@ async function optimizeMonkeyC(fnMap) {
                 break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    return optimizeCall(state, node.expression, node);
+                    return replace(optimizeCall(state, node.expression, node), node.expression);
                 }
                 else if (node.expression.type === "AssignmentExpression") {
                     if (node.expression.right.type === "CallExpression") {
@@ -1373,14 +1645,10 @@ async function optimizeMonkeyC(fnMap) {
                         }
                         if (!ok && node.expression.operator == "=") {
                             const [, result] = state.lookup(node.expression.left);
-                            ok = result != null;
+                            ok = !!result;
                         }
                         if (ok) {
-                            const ret = optimizeCall(state, node.expression.right, node.expression);
-                            if (ret && ret.type === "BlockStatement") {
-                                const r2 = state.traverse(ret);
-                                return r2 === false || r2 ? r2 : ret;
-                            }
+                            return replace(optimizeCall(state, node.expression.right, node.expression), node.expression.right);
                         }
                     }
                 }
@@ -1388,12 +1656,9 @@ async function optimizeMonkeyC(fnMap) {
                     const ret = unused(node.expression, true);
                     if (ret) {
                         return ret
-                            .map((s) => {
-                            const r2 = state.traverse(s);
-                            return r2 === false || r2 ? r2 : s;
-                        })
+                            .map((r) => replace(r, r))
                             .flat(1)
-                            .filter((s) => s !== false);
+                            .filter((s) => !!s);
                     }
                 }
                 break;
@@ -1412,6 +1677,9 @@ async function optimizeMonkeyC(fnMap) {
     delete state.post;
     const cleanup = (node) => {
         switch (node.type) {
+            case "ThisExpression":
+                node.text = "self";
+                break;
             case "EnumStringBody":
                 if (node.members.every((m) => {
                     const name = "name" in m ? m.name : m.id.name;
@@ -1436,19 +1704,24 @@ async function optimizeMonkeyC(fnMap) {
                 if (!node.body.members.length) {
                     if (!node.id)
                         return false;
-                    if (!node.body["enumType"]) {
+                    if (!node.body.enumType) {
                         throw new Error("Missing enumType on optimized enum");
                     }
-                    replace(node, {
+                    return {
                         type: "TypedefDeclaration",
                         id: node.id,
                         ts: {
                             type: "UnaryExpression",
-                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            argument: {
+                                type: "TypeSpecList",
+                                ts: [
+                                    node.body.enumType,
+                                ],
+                            },
                             prefix: true,
                             operator: " as",
                         },
-                    });
+                    };
                 }
                 break;
             case "VariableDeclaration": {
@@ -1471,6 +1744,19 @@ async function optimizeMonkeyC(fnMap) {
                     return false;
                 }
                 break;
+            case "ClassDeclaration":
+            case "ModuleDeclaration":
+                // none of the attributes means anything on classes and
+                // modules, and the new compiler complains about some
+                // of them. Just drop them all.
+                if (node.attrs && node.attrs.access) {
+                    if (node.attrs.attributes) {
+                        delete node.attrs.access;
+                    }
+                    else {
+                        delete node.attrs;
+                    }
+                }
         }
         return null;
     };
@@ -1486,9 +1772,12 @@ async function optimizeMonkeyC(fnMap) {
     return state.diagnostics;
 }
 function optimizeCall(state, node, context) {
-    const [name, results] = state.lookup(node.callee);
+    const [name, results] = state.lookupNonlocal(node.callee);
     const callees = results &&
-        results.filter((c) => c.type === "FunctionDeclaration");
+        results
+            .map((r) => r.results)
+            .flat()
+            .filter((c) => c.type === "FunctionDeclaration");
     if (!callees || !callees.length) {
         const n = name ||
             ("name" in node.callee && node.callee.name) ||
@@ -1593,6 +1882,10 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
 
 
 
+
+
+
+
 /*
  * This is an unfortunate hack. I want to be able to extract things
  * like the types of all of a Class's variables (in particular the type
@@ -1603,16 +1896,30 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
  * but those are at least in a standard format.
  */
 // Extract all enum values from api.mir
-async function api_getApiMapping(state) {
+async function api_getApiMapping(state, barrelList) {
     // get the path to the currently active sdk
     const parser = (prettier_plugin_monkeyc_default()).parsers.monkeyc;
     const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
+    const rezDecl = `module Rez { ${[
+        "Drawables",
+        "Fonts",
+        "JsonData",
+        "Layouts",
+        "Menus",
+        "Strings",
+    ]
+        .map((s) => `  module ${s} {}\n`)
+        .join("")}}`;
     const api = (await promises_namespaceObject.readFile(`${sdk}bin/api.mir`))
         .toString()
         .replace(/\r\n/g, "\n")
         .replace(/^\s*\[.*?\]\s*$/gm, "")
         //.replace(/(COLOR_TRANSPARENT|LAYOUT_[HV]ALIGN_\w+) = (\d+)/gm, "$1 = -$2")
-        .replace(/^(\s*type)\s/gm, "$1def ");
+        .replace(/^(\s*type)\s/gm, "$1def ") +
+        (barrelList || [])
+            .map((name) => `module ${name} { ${rezDecl} }`)
+            .concat(rezDecl)
+            .join("");
     try {
         const result = api_collectNamespaces(parser.parse(api, null, {
             filepath: "api.mir",
@@ -1626,23 +1933,24 @@ async function api_getApiMapping(state) {
                 return decls[0];
             }, result);
             const value = api_isStateNode(vs) ? vs.node : vs;
-            if (value.type !== "EnumStringMember" &&
-                (value.type !== "VariableDeclarator" || value.kind != "const")) {
+            if (!value ||
+                (value.type !== "EnumStringMember" &&
+                    (value.type !== "VariableDeclarator" || value.kind != "const"))) {
                 throw `Negative constant ${fixup} did not refer to a constant`;
             }
-            const init = value.init;
+            const init = getLiteralNode(value.init);
             if (!init || init.type !== "Literal") {
                 throw `Negative constant ${fixup} was not a Literal`;
             }
             if (typeof init.value !== "number") {
-                console.log(`Negative fixup ${fixup} was already not a number!`);
+                console.log(`Negative fixup ${fixup} was not a number!`);
             }
             else if (init.value > 0) {
                 init.value = -init.value;
                 init.raw = "-" + init.raw;
             }
             else {
-                console.log(`Negative fixup ${fixup} was already negative!`);
+                // console.log(`Negative fixup ${fixup} was already negative!`);
             }
         });
         return result;
@@ -1661,67 +1969,197 @@ function api_isStateNode(node) {
 function api_variableDeclarationName(node) {
     return ("left" in node ? node.left : node).name;
 }
-function checkOne(ns, decls, name) {
+function lookupToStateNodeDecls(results) {
+    return results.reduce((result, current) => current.results.length
+        ? result
+            ? result.concat(current.results)
+            : current.results
+        : result, null);
+}
+function checkOne(state, ns, decls, node, isStatic) {
+    // follow the superchain, looking up node in each class
+    const superChain = (cls) => {
+        if (!cls.superClass || cls.superClass === true) {
+            return null;
+        }
+        return cls.superClass.reduce((result, sup) => {
+            const sdecls = sup[decls];
+            const next = api_hasProperty(sdecls, node.name)
+                ? sdecls[node.name]
+                : superChain(sup);
+            return next ? (result ? result.concat(next) : next) : result;
+        }, null);
+    };
+    const lookupInContext = (ns) => {
+        const [, lkup] = lookup(state, decls, node, null, ns.stack);
+        return lkup && lookupToStateNodeDecls(lkup);
+    };
+    // follow the superchain, looking up node in each class's scope
+    const superChainScopes = (ns) => {
+        const result = lookupInContext(ns);
+        if (result)
+            return result;
+        if (!ns.superClass || ns.superClass === true) {
+            return null;
+        }
+        return ns.superClass.reduce((result, sup) => {
+            const next = superChainScopes(sup);
+            return next ? (result ? result.concat(next) : next) : result;
+        }, null);
+    };
     if (api_isStateNode(ns)) {
-        if (api_hasProperty(ns[decls], name)) {
-            return ns[decls][name];
-        }
-        if (ns.type == "ClassDeclaration" &&
-            ns.superClass &&
-            ns.superClass !== true) {
-            const found = ns.superClass
-                .map((cls) => checkOne(cls, decls, name))
-                .filter((n) => n != null)
-                .flat(1);
-            return found.length ? found : null;
+        const ndecls = ns[decls];
+        if (api_hasProperty(ndecls, node.name)) {
+            return ndecls[node.name];
+        }
+        switch (ns.type) {
+            case "ClassDeclaration":
+                if (!isStatic) {
+                    return superChain(ns) || superChainScopes(ns) || false;
+                }
+            // fall through
+            case "ModuleDeclaration":
+                return lookupInContext(ns) || false;
         }
     }
     return null;
 }
-function lookup(state, decls, node, name, stack) {
-    stack || (stack = state.stack);
+function sameStateNodeDecl(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (!api_isStateNode(a) || a.type !== b.type)
+        return false;
+    return (a.node === b.node ||
+        a.type === "Program" ||
+        (a.type === "ModuleDeclaration" && a.fullName === b.fullName));
+}
+function sameLookupDefinition(a, b) {
+    return (
+    // sameStateNodeDecl(a.parent, b.parent) &&
+    (0,external_util_cjs_namespaceObject.sameArrays)(a.results, b.results, (ar, br) => sameStateNodeDecl(ar, br)));
+}
+function api_sameLookupResult(a, b) {
+    return (0,external_util_cjs_namespaceObject.sameArrays)(a, b, sameLookupDefinition);
+}
+/**
+ *
+ * @param state    - The ProgramState
+ * @param decls    - The field to use to look things up. either "decls" or "type_decls"
+ * @param node     - The node to lookup
+ * @param name     - Overrides the name of the node.
+ * @param stack    - if provided, use this stack, rather than the current
+ *                   state.stack for the lookup
+ * @param nonlocal - when true, a plain identifier will be looked up as a
+ *                   non-local. This is needed when looking up a callee.
+ *                   If the callee is a MemberExpression, the flag is ignored.
+ * @returns
+ *  - [string, LookupDefinition[]] - if the lookup succeeds
+ *  - [false, false] - if the lookup fails, but its not an error because its not the kind of expression we can lookup
+ *  - [null, null] - if the lookup fails unexpectedly.
+ */
+function lookup(state, decls, node, name, maybeStack, nonlocal) {
+    const stack = maybeStack || state.stack;
     switch (node.type) {
         case "MemberExpression": {
             if (node.property.type != "Identifier" || node.computed)
                 break;
-            const [, module, where] = lookup(state, decls, node.object, name, stack);
-            if (module && module.length === 1) {
-                const result = checkOne(module[0], decls, node.property.name);
-                if (result) {
-                    return [
-                        name || node.property.name,
-                        result,
-                        where.concat(module[0]),
-                    ];
+            const property = node.property;
+            let result;
+            if (node.object.type === "ThisExpression") {
+                [, result] = lookup(state, decls, node.property, name, stack, true);
+            }
+            else {
+                const [, results] = lookup(state, decls, node.object, name, stack, false);
+                if (results === false)
+                    break;
+                if (!results)
+                    return [null, null];
+                result = results.reduce((current, lookupDef) => {
+                    const items = lookupDef.results
+                        .map((module) => {
+                        const res = checkOne(state, module, decls, property, false);
+                        return res ? { parent: module, results: res } : null;
+                    })
+                        .filter((r) => r != null);
+                    if (!items.length)
+                        return current;
+                    return current ? current.concat(items) : items;
+                }, null);
+                if (!result &&
+                    results.some((ld) => ld.results.some((sn) => (api_isStateNode(sn) && sn.fullName?.match(/^\$\.(\w+\.)?Rez\./)) ||
+                        sn.type === "VariableDeclarator" ||
+                        sn.type === "Identifier" ||
+                        sn.type === "BinaryExpression" ||
+                        (sn.type === "ClassDeclaration" &&
+                            property.name === "initialize")))) {
+                    // - The Rez module can contain lots of things from the resource
+                    //   compiler which we don't track.
+                    // - Variables, and formal parameters would require type tracking
+                    //   which we don't yet do
+                    // - Its ok to call an undeclared initialize method.
+                    // Report them all as "expected failures".
+                    return [false, false];
                 }
             }
-            break;
+            if (!result)
+                return [null, null];
+            return [name || property.name, result];
         }
         case "ThisExpression": {
-            for (let i = stack.length; i--;) {
+            for (let i = stack.length;;) {
                 const si = stack[i];
                 if (si.type == "ModuleDeclaration" ||
                     si.type == "ClassDeclaration" ||
                     !i) {
-                    return [name || si.name, [si], stack.slice(0, i)];
+                    return [
+                        name || si.name,
+                        [{ parent: i ? stack[i - 1] : null, results: [si] }],
+                    ];
                 }
             }
-            break;
         }
         case "Identifier": {
             if (node.name == "$") {
-                return [name || node.name, [stack[0]], []];
+                return [name || node.name, [{ parent: null, results: [stack[0]] }]];
             }
+            let inStatic = false;
+            let checkedImports = false;
             for (let i = stack.length; i--;) {
-                const result = checkOne(stack[i], decls, node.name);
-                if (result) {
-                    return [name || node.name, result, stack.slice(0, i + 1)];
+                const si = stack[i];
+                switch (si.type) {
+                    case "ClassDeclaration":
+                    case "ModuleDeclaration":
+                    case "Program":
+                        if (!checkedImports) {
+                            checkedImports = true;
+                            const results = findUsingForNode(state, stack, i, node, decls === "type_decls");
+                            if (results) {
+                                return [name || node.name, [{ parent: si, results }]];
+                            }
+                        }
+                        break;
+                    case "FunctionDeclaration":
+                        inStatic = si.isStatic === true;
+                    // fall through
+                    default:
+                        if (nonlocal)
+                            continue;
+                        break;
+                }
+                const results = checkOne(state, si, decls, node, inStatic);
+                if (results) {
+                    return [name || node.name, [{ parent: si, results }]];
+                }
+                else if (results === false) {
+                    break;
                 }
             }
-            break;
+            return [null, null];
         }
     }
-    return [null, null, null];
+    return [false, false];
 }
 function api_collectNamespaces(ast, stateIn) {
     const state = (stateIn || {});
@@ -1737,14 +2175,15 @@ function api_collectNamespaces(ast, stateIn) {
             let low = 0, high = ast.comments.length;
             while (high > low) {
                 const mid = (low + high) >> 1;
-                if (ast.comments[mid].start < node.start) {
+                if ((ast.comments[mid].start || 0) < node.start) {
                     low = mid + 1;
                 }
                 else {
                     high = mid;
                 }
             }
-            while (high < ast.comments.length && ast.comments[high].end < node.end) {
+            while (high < ast.comments.length &&
+                (ast.comments[high].end || 0) < node.end) {
                 high++;
             }
             if (high > low) {
@@ -1753,10 +2192,14 @@ function api_collectNamespaces(ast, stateIn) {
         }
     };
     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 = false;
-    state.traverse = (root) => api_traverseAst(root, (node) => {
+    state.traverse = (root) => ast_traverseAst(root, (node) => {
         try {
             if (state.shouldExclude && state.shouldExclude(node)) {
                 // don't visit any children, but do call post
@@ -1767,14 +2210,60 @@ function api_collectNamespaces(ast, stateIn) {
                     if (state.stack.length != 1) {
                         throw new Error("Unexpected stack length for Program node");
                     }
+                    state.stack[0].node = node;
                     break;
                 case "TypeSpecList":
                     state.inType = true;
                     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];
+                        }
+                        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;
+                }
+                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] },
+                        });
+                    }
+                    break;
                 case "BlockStatement": {
                     const [parent] = state.stack.slice(-1);
-                    if (parent.type != "FunctionDeclaration" &&
-                        parent.type != "BlockStatement") {
+                    if (parent.node === node ||
+                        (parent.type != "FunctionDeclaration" &&
+                            parent.type != "BlockStatement")) {
                         break;
                     }
                     // fall through
@@ -1820,6 +2309,9 @@ function api_collectNamespaces(ast, stateIn) {
                         parent.decls[name].push(elm);
                         if (node.type == "ModuleDeclaration" ||
                             node.type == "ClassDeclaration") {
+                            // Inject the class/module name into itself,
+                            // so you can say Graphics.Graphics.Graphics.COLOR_RED
+                            elm.decls = { [name]: [elm] };
                             if (!parent.type_decls)
                                 parent.type_decls = {};
                             if (!api_hasProperty(parent.type_decls, name)) {
@@ -1867,7 +2359,7 @@ function api_collectNamespaces(ast, stateIn) {
                     if (!parent.decls)
                         parent.decls = {};
                     const decls = parent.decls;
-                    const stack = state.stack.slice();
+                    const stack = state.stackClone();
                     node.declarations.forEach((decl) => {
                         const name = api_variableDeclarationName(decl.id);
                         if (!api_hasProperty(decls, name)) {
@@ -1971,8 +2463,14 @@ function api_collectNamespaces(ast, stateIn) {
                         state.inType = true;
                         break;
                 }
-                if (state.stack.slice(-1).pop()?.node === node) {
-                    state.stack.pop();
+                const [parent] = state.stack.slice(-1);
+                if (parent.node === node ||
+                    (node.type === "CatchClause" && parent.node === node.body)) {
+                    delete parent.usings;
+                    delete parent.imports;
+                    if (node.type != "Program") {
+                        state.stack.pop();
+                    }
                 }
             }
             if (ret === false) {
@@ -1993,77 +2491,7 @@ function api_collectNamespaces(ast, stateIn) {
     }
     return state.stack[0];
 }
-function isMCTreeNode(node) {
-    return node ? typeof node === "object" && "type" in node : false;
-}
-/*
- * Traverse the ast rooted at node, calling pre before
- * visiting each node, and post after.
- *
- *  - if pre returns false, the node is not traversed, and
- *    post is not called;
- *  - if pre returns a list of child nodes, only those will
- *    be traversed
- *  - otherwise all child nodes are traversed
- *
- *  - if post returns false, the node it was called on is
- *    removed.
- */
-function api_traverseAst(node, pre, post) {
-    const nodes = pre && pre(node);
-    if (nodes === false)
-        return;
-    for (const key of nodes || Object.keys(node)) {
-        const value = node[key];
-        if (!value)
-            continue;
-        if (Array.isArray(value)) {
-            const values = value;
-            const deletions = values.reduce((state, obj, i) => {
-                if (isMCTreeNode(obj)) {
-                    const repl = api_traverseAst(obj, pre, post);
-                    if (repl === false) {
-                        if (!state)
-                            state = {};
-                        state[i] = true;
-                    }
-                    else if (repl != null) {
-                        if (!state)
-                            state = {};
-                        values[i] = repl;
-                    }
-                }
-                return state;
-            }, null);
-            if (deletions) {
-                values.splice(0, values.length, ...values.filter((obj, i) => deletions[i] !== true).flat(1));
-            }
-        }
-        else if (isMCTreeNode(value)) {
-            const repl = api_traverseAst(value, pre, post);
-            if (repl === false) {
-                delete node[key];
-            }
-            else if (repl != null) {
-                if (Array.isArray(repl)) {
-                    throw new Error("Array returned by traverseAst in Node context");
-                }
-                node[key] = repl;
-            }
-        }
-    }
-    return post && post(node);
-}
-function formatAst(node, monkeyCSource = null) {
-    if ("comments" in node && !monkeyCSource) {
-        // Prettier inserts comments by using the source location to
-        // find the original comment, rather than using the contents
-        // of the comment as reported by the comment nodes themselves.
-        // If all we've got is the ast, rather than the actual
-        // source code, this goes horribly wrong, so just drop all
-        // the comments.
-        delete node.comments;
-    }
+function api_formatAst(node, monkeyCSource = null) {
     /*
      * The estree printer sometimes looks at the parent node without
      * checking that there *is* a parent node (eg it assumes all
@@ -2104,7 +2532,7 @@ function handleException(state, node, exception) {
             .filter((e) => e != null)
             .join(".");
         const location = node.loc && node.loc.source
-            ? `${node.loc.source}:${node.start || 0}:${node.end || 0}`
+            ? `${node.loc.source}:${node.loc.start.line || 0}:${node.loc.end.line || 0}`
             : "<unknown>";
         const message = `Got exception \`${exception instanceof Error
             ? exception.message
@@ -2116,9 +2544,65 @@ function handleException(state, node, exception) {
             exception = new Error(message);
         }
     }
-    finally {
+    catch (ex) {
         throw exception;
     }
+    throw exception;
+}
+function findUsing(state, stack, using) {
+    if (using.module)
+        return using.module;
+    let module = stack[0];
+    const find = (node) => {
+        let name;
+        if (node.type == "Identifier") {
+            name = node.name;
+        }
+        else {
+            find(node.object);
+            name = node.property.name;
+        }
+        if (api_hasProperty(module.decls, name)) {
+            const decls = module.decls[name];
+            if (decls &&
+                decls.length === 1 &&
+                decls[0].type === "ModuleDeclaration") {
+                module = decls[0];
+                return true;
+            }
+        }
+        return false;
+    };
+    if (find(using.node.id)) {
+        using.module = module;
+        return using.module;
+    }
+    if (state.config?.checkInvalidSymbols !== "OFF") {
+        inliner_diagnostic(state, using.node.id.loc, `Unable to resolve import of ${api_formatAst(using.node.id)}`, state.config?.checkInvalidSymbols || "WARNING");
+    }
+    return null;
+}
+function findUsingForNode(state, stack, i, node, isType) {
+    while (i >= 0) {
+        const si = stack[i--];
+        if (api_hasProperty(si.usings, node.name)) {
+            const using = si.usings[node.name];
+            const module = findUsing(state, stack, using);
+            return module && [module];
+        }
+        if (si.imports && isType) {
+            for (let j = si.imports.length; j--;) {
+                const using = si.imports[j];
+                const module = findUsing(state, stack, using);
+                if (module) {
+                    if (api_hasProperty(module.type_decls, node.name)) {
+                        return module.type_decls[node.name];
+                    }
+                }
+            }
+        }
+    }
+    return null;
 }
 
 var __webpack_export_target__ = exports;