@markw65/monkeyc-optimizer 1.0.13 → 1.0.16

package/build/api.cjs

@@ -233,6 +233,276 @@ const promises_namespaceObject = require("fs/promises");
 var standalone = __webpack_require__(3945);
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
+;// CONCATENATED MODULE: ./src/inliner.ts
+
+function canInline(state, func, args) {
+    // determine whether decl might be changed by a function call
+    // 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")
+                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;
+            }
+        }
+        return null;
+    };
+    const safeArgs = [];
+    let allSafe = true;
+    if (!args.every((arg) => {
+        switch (arg.type) {
+            case "Literal":
+                safeArgs.push(true);
+                return true;
+            case "Identifier":
+            case "MemberExpression": {
+                const [, results] = state.lookup(arg);
+                if (!results || results.length !== 1)
+                    return false;
+                const safety = getSafety(results[0]);
+                if (safety === null)
+                    return false;
+                if (!safety)
+                    allSafe = false;
+                safeArgs.push(safety);
+                return true;
+            }
+        }
+        return false;
+    })) {
+        return false;
+    }
+    if (allSafe)
+        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) => {
+        switch (node.type) {
+            case "CallExpression":
+            case "NewExpression":
+                callSeen = true;
+                break;
+            case "Identifier":
+                if (callSeen &&
+                    hasProperty(params, node.name) &&
+                    !safeArgs[params[node.name]]) {
+                    ok = false;
+                }
+        }
+    });
+    return ok;
+}
+function inliningLooksUseful(func, node) {
+    while (true) {
+        if (node.type === "BinaryExpression" && node.operator === "as") {
+            node = node.left;
+        }
+        else if (node.type === "UnaryExpression" && node.operator === " as") {
+            node = node.argument;
+        }
+        else {
+            break;
+        }
+    }
+    if (node.type === "Literal")
+        return true;
+    if (node.type === "Identifier") {
+        if (func.params.length === 1 &&
+            variableDeclarationName(func.params[0]) === node.name) {
+            return 1;
+        }
+        return true;
+    }
+    return false;
+}
+function inliner_shouldInline(state, func, args) {
+    if (!func.node.body ||
+        func.node.body.body.length !== 1 ||
+        func.node.body.body[0].type !== "ReturnStatement" ||
+        !func.node.body.body[0].argument ||
+        func.node.params.length !== args.length) {
+        return false;
+    }
+    const autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
+    const excludeAnnotations = (func.node.loc?.source &&
+        state.fnMap[func.node.loc?.source].excludeAnnotations) ||
+        {};
+    return ((autoInline ||
+        (func.node.attrs &&
+            func.node.attrs.attrs &&
+            func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+                (attr.argument.name === "inline" ||
+                    (attr.argument.name.startsWith("inline_") &&
+                        hasProperty(excludeAnnotations, attr.argument.name.substring(7))))))) &&
+        (autoInline === 1 || canInline(state, func, args)));
+}
+function inliner_inlineFunction(state, func, call) {
+    const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
+    const params = Object.fromEntries(func.node.params.map((param, i) => [variableDeclarationName(param), i]));
+    try {
+        const result = traverseAst(retArg, (node) => {
+            switch (node.type) {
+                case "MemberExpression":
+                    if (!node.computed) {
+                        return ["object"];
+                    }
+                    break;
+                case "BinaryExpression":
+                    if (node.operator === "as") {
+                        return ["left"];
+                    }
+                    break;
+                case "UnaryExpression":
+                    if (node.operator === " as") {
+                        return [];
+                    }
+            }
+            return null;
+        }, (node) => {
+            switch (node.type) {
+                case "Identifier": {
+                    if (hasProperty(params, node.name)) {
+                        return call.arguments[params[node.name]];
+                    }
+                    const rep = fixNodeScope(state, node, func.stack);
+                    if (!rep) {
+                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                    }
+                    return rep;
+                }
+            }
+            return null;
+        }) || retArg;
+        result.loc = call.loc;
+        result.start = call.start;
+        result.end = call.end;
+        return result;
+    }
+    catch (ex) {
+        if (ex instanceof Error) {
+            if (ex.message.startsWith("Inliner: ")) {
+                return null;
+            }
+        }
+        throw ex;
+    }
+}
+function applyTypeIfNeeded(node) {
+    if ("enumType" in node && node.enumType) {
+        node = {
+            type: "BinaryExpression",
+            operator: "as",
+            left: node,
+            right: { type: "TypeSpecList", ts: [node.enumType] },
+        };
+    }
+    return node;
+}
+function fixNodeScope(state, lookupNode, nodeStack) {
+    const [, original] = state.lookup(lookupNode, null, nodeStack);
+    if (!original) {
+        return null;
+    }
+    const [, current] = state.lookup(lookupNode);
+    // For now, leave it alone if it already maps to the same thing.
+    // 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])) {
+        return lookupNode;
+    }
+    const node = lookupNode.type === "Identifier"
+        ? lookupNode
+        : lookupNode.property;
+    if (original.length === 1 && original[0].type === "EnumStringMember") {
+        return applyTypeIfNeeded(original[0].init);
+    }
+    const prefixes = original.map((sn) => {
+        if (isStateNode(sn) && sn.fullName) {
+            return sn.fullName;
+        }
+        return "";
+    });
+    if (prefixes.length &&
+        prefixes[0].startsWith("$.") &&
+        prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
+        const prefix = prefixes[0].split(".").slice(0, -1).reverse();
+        let found = false;
+        return prefix.reduce((current, name) => {
+            if (found)
+                return current;
+            const [, results] = state.lookup(current);
+            if (results &&
+                results.length === original.length &&
+                results.every((result, i) => result === original[i])) {
+                found = true;
+                return current;
+            }
+            const object = typeof name === "string"
+                ? {
+                    type: "Identifier",
+                    name,
+                    start: node.start,
+                    end: node.end,
+                    loc: node.loc,
+                }
+                : name;
+            let root = null;
+            let property = current;
+            while (property.type !== "Identifier") {
+                root = property;
+                property = property.object;
+            }
+            const mb = {
+                type: "MemberExpression",
+                object,
+                property,
+                computed: false,
+                start: node.start,
+                end: node.end,
+                loc: node.loc,
+            };
+            if (root) {
+                root.object = mb;
+            }
+            else {
+                current = mb;
+            }
+            return current;
+        }, node);
+    }
+    return null;
+}
+
 ;// CONCATENATED MODULE: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
@@ -240,6 +510,7 @@ 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);
@@ -248,11 +519,21 @@ function processImports(allImports, lookup) {
             if (!parent.decls)
                 parent.decls = {};
             const decls = parent.decls;
-            if (!hasProperty(parent.decls, name))
-                parent.decls[name] = [];
+            if (!hasProperty(decls, name))
+                decls[name] = [];
             module.forEach((m) => {
                 if (isStateNode(m) && m.type == "ModuleDeclaration") {
                     pushUnique(decls[name], m);
+                    if (node.type == "ImportModule" && m.type_decls) {
+                        if (!parent.type_decls)
+                            parent.type_decls = {};
+                        const tdecls = parent.type_decls;
+                        Object.entries(m.type_decls).forEach(([name, decls]) => {
+                            if (!hasProperty(tdecls, name))
+                                tdecls[name] = [];
+                            decls.forEach((decl) => pushUnique(tdecls[name], decl));
+                        });
+                    }
                 }
             });
         }
@@ -261,11 +542,39 @@ function processImports(allImports, lookup) {
 function collectClassInfo(state) {
     state.allClasses.forEach((elm) => {
         if (elm.node.superClass) {
-            const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+            const [name, classes] = state.lookup(elm.node.superClass, null, elm.stack);
             const superClass = classes &&
                 classes.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) {
+                /*
+                 * The runtime behavior of monkeyc is strange. Lookups
+                 * of the name of the superclass, either bare, or via self.<name>
+                 * always find the superclass, even if there's a member variable
+                 * or method of the same name. So its ok to just overwrite
+                 * elm.decls[name] here.
+                 *
+                 * ie
+                 *
+                 * class A { function foo() as Number { return 1; } }
+                 * class B { function foo() as String { return "B"; } }
+                 * class C extends A {
+                 *   var A as B = new B();
+                 *   function initialize() {
+                 *     A.initialize(); // class A's initialize
+                 *     A.foo(); // returns 1
+                 *     self.A.foo(); // still returns 1
+                 *   }
+                 * }
+                 *
+                 * The typechecker seems to get confused in some circumstances
+                 * though (ie it doesn't always use the same rules)
+                 */
+                if (!elm.decls)
+                    elm.decls = {};
+                elm.decls[name] = elm.superClass;
+            }
         }
     });
     const markOverrides = (cls, scls) => {
@@ -321,32 +630,36 @@ function getFileASTs(fnMap) {
     }, true));
 }
 async function analyze(fnMap) {
-    let excludeAnnotations;
     let hasTests = false;
     const allImports = [];
     const preState = {
+        fnMap,
         allFunctions: [],
         allClasses: [],
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
                 "attrs" in node.attrs &&
-                node.attrs.attrs) {
-                return node.attrs.attrs.reduce((drop, attr) => {
-                    if (attr.type != "UnaryExpression")
-                        return drop;
-                    if (attr.argument.type != "Identifier")
+                node.attrs.attrs &&
+                node.loc?.source) {
+                const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
+                if (excludeAnnotations) {
+                    return node.attrs.attrs.reduce((drop, attr) => {
+                        if (attr.type != "UnaryExpression")
+                            return drop;
+                        if (attr.argument.type != "Identifier")
+                            return drop;
+                        if (hasProperty(excludeAnnotations, attr.argument.name)) {
+                            return true;
+                        }
+                        if (attr.argument.name == "test") {
+                            hasTests = true;
+                        }
                         return drop;
-                    if (hasProperty(excludeAnnotations, attr.argument.name)) {
-                        return true;
-                    }
-                    if (attr.argument.name == "test") {
-                        hasTests = true;
-                    }
-                    return drop;
-                }, false);
+                    }, false);
+                }
             }
-            return null;
+            return false;
         },
         post(node, state) {
             switch (node.type) {
@@ -393,7 +706,6 @@ async function analyze(fnMap) {
         if (!ast) {
             throw parserError || new Error(`Failed to parse ${name}`);
         }
-        excludeAnnotations = value.excludeAnnotations;
         hasTests = false;
         collectNamespaces(ast, state);
         value.hasTests = hasTests;
@@ -417,8 +729,8 @@ function getLiteralFromDecls(decls) {
     let result = null;
     if (decls.every((d) => {
         if (d.type === "EnumStringMember" ||
-            (d.type === "VariableDeclarator" && d.kind === "const")) {
-            const init = getLiteralNode(d.init);
+            (d.type === "VariableDeclarator" && d.node.kind === "const")) {
+            const init = getLiteralNode(d.type === "EnumStringMember" ? d.init : d.node.init);
             if (!init)
                 return false;
             if (!result) {
@@ -700,11 +1012,12 @@ async function optimizeMonkeyC(fnMap) {
      * anywhere in its superClass chain.
      */
     const checkInherited = (elm, name) => elm.superClass === true ||
-        elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
-            sc.decls[name].some((f) => isStateNode(f) &&
-                f.type == "FunctionDeclaration" &&
-                maybeCalled(f.node))) ||
-            (sc.superClass && checkInherited(sc, name)));
+        (elm.superClass != null &&
+            elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
+                sc.decls[name].some((f) => isStateNode(f) &&
+                    f.type == "FunctionDeclaration" &&
+                    maybeCalled(f.node))) ||
+                (sc.superClass && checkInherited(sc, name))));
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
@@ -947,11 +1260,9 @@ async function optimizeMonkeyC(fnMap) {
                     }
                     return null;
                 }
-                if (callees.length == 1) {
-                    const callee = isStateNode(callees[0]) && callees[0].node;
-                    if (callee &&
-                        callee.type == "FunctionDeclaration" &&
-                        callee.optimizable &&
+                if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
+                    const callee = callees[0].node;
+                    if (callee.optimizable &&
                         !callee.hasOverride &&
                         node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
                         const ret = evaluateFunction(callee, node.arguments);
@@ -960,6 +1271,13 @@ async function optimizeMonkeyC(fnMap) {
                             return null;
                         }
                     }
+                    if (shouldInline(state, callees[0], node.arguments)) {
+                        const ret = inlineFunction(state, callees[0], node);
+                        if (ret) {
+                            replace(node, ret);
+                            return null;
+                        }
+                    }
                 }
                 if (!hasProperty(state.calledFunctions, name)) {
                     state.calledFunctions[name] = [];
@@ -973,71 +1291,79 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         collectNamespaces(f.ast, state);
     });
-    Object.values(fnMap).forEach((f) => {
-        traverseAst(f.ast, undefined, (node) => {
-            switch (node.type) {
-                case "EnumStringBody":
-                    if (node.members.every((m) => {
-                        const name = "name" in m ? m.name : m.id.name;
-                        return (hasProperty(state.index, name) &&
-                            !hasProperty(state.exposed, name));
-                    })) {
-                        node.enumType = [
-                            ...new Set(node.members.map((m) => {
-                                if (!("init" in m))
-                                    return "Number";
-                                const [node, type] = getNodeValue(m.init);
-                                if (!node) {
-                                    throw new Error("Failed to get type for eliminated enum");
-                                }
-                                return type;
-                            })),
-                        ].join(" or ");
-                        node.members.splice(0);
-                    }
-                    break;
-                case "EnumDeclaration":
-                    if (!node.body.members.length) {
-                        if (!node.id)
-                            return false;
-                        if (!node.body["enumType"]) {
-                            throw new Error("Missing enumType on optimized enum");
-                        }
-                        replace(node, {
-                            type: "TypedefDeclaration",
-                            id: node.id,
-                            ts: {
-                                type: "UnaryExpression",
-                                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
-                                prefix: true,
-                                operator: " as",
-                            },
-                        });
-                    }
-                    break;
-                case "VariableDeclaration": {
-                    node.declarations = node.declarations.filter((d) => {
-                        const name = variableDeclarationName(d.id);
-                        return (!hasProperty(state.index, name) ||
-                            hasProperty(state.exposed, name));
-                    });
-                    if (!node.declarations.length) {
-                        return false;
-                    }
-                    break;
+    delete state.pre;
+    delete state.post;
+    const cleanup = (node) => {
+        switch (node.type) {
+            case "EnumStringBody":
+                if (node.members.every((m) => {
+                    const name = "name" in m ? m.name : m.id.name;
+                    return (hasProperty(state.index, name) &&
+                        !hasProperty(state.exposed, name));
+                })) {
+                    node.enumType = [
+                        ...new Set(node.members.map((m) => {
+                            if (!("init" in m))
+                                return "Number";
+                            const [node, type] = getNodeValue(m.init);
+                            if (!node) {
+                                throw new Error("Failed to get type for eliminated enum");
+                            }
+                            return type;
+                        })),
+                    ].join(" or ");
+                    node.members.splice(0);
                 }
-                case "ClassElement":
-                    if (!node.item) {
-                        return false;
-                    }
-                    break;
-                case "FunctionDeclaration":
-                    if (!maybeCalled(node)) {
+                break;
+            case "EnumDeclaration":
+                if (!node.body.members.length) {
+                    if (!node.id)
                         return false;
+                    if (!node.body["enumType"]) {
+                        throw new Error("Missing enumType on optimized enum");
                     }
-                    break;
+                    replace(node, {
+                        type: "TypedefDeclaration",
+                        id: node.id,
+                        ts: {
+                            type: "UnaryExpression",
+                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            prefix: true,
+                            operator: " as",
+                        },
+                    });
+                }
+                break;
+            case "VariableDeclaration": {
+                node.declarations = node.declarations.filter((d) => {
+                    const name = variableDeclarationName(d.id);
+                    return (!hasProperty(state.index, name) || hasProperty(state.exposed, name));
+                });
+                if (!node.declarations.length) {
+                    return false;
+                }
+                break;
             }
-            return null;
+            case "ClassElement":
+                if (!node.item) {
+                    return false;
+                }
+                break;
+            case "FunctionDeclaration":
+                if (!maybeCalled(node)) {
+                    return false;
+                }
+                break;
+        }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        traverseAst(f.ast, undefined, (node) => {
+            const ret = cleanup(node);
+            if (ret === false) {
+                state.removeNodeComments(node, f.ast);
+            }
+            return ret;
         });
     });
 }
@@ -1133,13 +1459,14 @@ async function api_getApiMapping(state) {
             filepath: "api.mir",
         }), state);
         negativeFixups.forEach((fixup) => {
-            const value = fixup.split(".").reduce((state, part) => {
+            const vs = fixup.split(".").reduce((state, part) => {
                 const decls = api_isStateNode(state) && state.decls?.[part];
                 if (!Array.isArray(decls) || decls.length != 1 || !decls[0]) {
                     throw `Failed to find and fix negative constant ${fixup}`;
                 }
                 return decls[0];
             }, result);
+            const value = api_isStateNode(vs) ? vs.node : vs;
             if (value.type !== "EnumStringMember" &&
                 (value.type !== "VariableDeclarator" || value.kind != "const")) {
                 throw `Negative constant ${fixup} did not refer to a constant`;
@@ -1175,6 +1502,68 @@ function api_isStateNode(node) {
 function api_variableDeclarationName(node) {
     return ("left" in node ? node.left : node).name;
 }
+function checkOne(ns, decls, name) {
+    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;
+        }
+    }
+    return null;
+}
+function lookup(state, decls, node, name, stack) {
+    stack || (stack = 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]),
+                    ];
+                }
+            }
+            break;
+        }
+        case "ThisExpression": {
+            for (let i = stack.length; i--;) {
+                const si = stack[i];
+                if (si.type == "ModuleDeclaration" ||
+                    si.type == "ClassDeclaration" ||
+                    !i) {
+                    return [name || si.name, [si], stack.slice(0, i)];
+                }
+            }
+            break;
+        }
+        case "Identifier": {
+            if (node.name == "$") {
+                return [name || node.name, [stack[0]], []];
+            }
+            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)];
+                }
+            }
+            break;
+        }
+    }
+    return [null, null, null];
+}
 function api_collectNamespaces(ast, stateIn) {
     const state = (stateIn || {});
     if (!state.index)
@@ -1184,57 +1573,30 @@ function api_collectNamespaces(ast, stateIn) {
             { type: "Program", name: "$", fullName: "$", node: undefined },
         ];
     }
-    const checkOne = (ns, name) => {
-        if (api_isStateNode(ns) && api_hasProperty(ns.decls, name)) {
-            return ns.decls[name];
-        }
-        return null;
-    };
-    state.lookup = (node, name, stack) => {
-        stack || (stack = state.stack);
-        switch (node.type) {
-            case "MemberExpression": {
-                if (node.property.type != "Identifier" || node.computed)
-                    break;
-                const [, module, where] = state.lookup(node.object, name, stack);
-                if (module && module.length === 1) {
-                    const result = checkOne(module[0], node.property.name);
-                    if (result) {
-                        return [
-                            name || node.property.name,
-                            result,
-                            where.concat(module[0]),
-                        ];
-                    }
+    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 < node.start) {
+                    low = mid + 1;
                 }
-                break;
-            }
-            case "ThisExpression": {
-                for (let i = stack.length; i--;) {
-                    const si = stack[i];
-                    if (si.type == "ModuleDeclaration" ||
-                        si.type == "ClassDeclaration" ||
-                        !i) {
-                        return [name || si.name, [si], stack.slice(0, i)];
-                    }
+                else {
+                    high = mid;
                 }
-                break;
             }
-            case "Identifier": {
-                if (node.name == "$") {
-                    return [name || node.name, [stack[0]], []];
-                }
-                for (let i = stack.length; i--;) {
-                    const result = checkOne(stack[i], node.name);
-                    if (result) {
-                        return [name || node.name, result, stack.slice(0, i + 1)];
-                    }
-                }
-                break;
+            while (high < ast.comments.length && ast.comments[high].end < node.end) {
+                high++;
+            }
+            if (high > low) {
+                ast.comments.splice(low, high - low);
             }
         }
-        return [null, null, null];
     };
+    state.lookup = (node, name, stack) => lookup(state, state.inType ? "type_decls" : "decls", node, name, stack);
+    state.lookupValue = (node, name, stack) => lookup(state, "decls", node, name, stack);
+    state.lookupType = (node, name, stack) => lookup(state, "type_decls", node, name, stack);
+    state.inType = false;
     state.traverse = (root) => api_traverseAst(root, (node) => {
         try {
             if (state.shouldExclude && state.shouldExclude(node)) {
@@ -1247,6 +1609,9 @@ function api_collectNamespaces(ast, stateIn) {
                         throw new Error("Unexpected stack length for Program node");
                     }
                     break;
+                case "TypeSpecList":
+                    state.inType = true;
+                    break;
                 case "BlockStatement": {
                     const [parent] = state.stack.slice(-1);
                     if (parent.type != "FunctionDeclaration" &&
@@ -1259,7 +1624,7 @@ function api_collectNamespaces(ast, stateIn) {
                 case "FunctionDeclaration":
                 case "ModuleDeclaration": {
                     const [parent] = state.stack.slice(-1);
-                    const name = "id" in node ? node.id && node.id.name : null;
+                    const name = "id" in node ? node.id && node.id.name : undefined;
                     const fullName = state.stack
                         .map((e) => e.name)
                         .concat(name)
@@ -1294,6 +1659,15 @@ function api_collectNamespaces(ast, stateIn) {
                             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 (!api_hasProperty(parent.type_decls, name)) {
+                                parent.type_decls[name] = [];
+                            }
+                            parent.type_decls[name].push(elm);
+                        }
                     }
                     break;
                 }
@@ -1308,14 +1682,25 @@ function api_collectNamespaces(ast, stateIn) {
                 }
                 // fall through
                 case "TypedefDeclaration": {
+                    state.inType = true;
                     const name = node.id.name;
                     const [parent] = state.stack.slice(-1);
-                    if (!parent.decls)
-                        parent.decls = {};
-                    if (!api_hasProperty(parent.decls, name)) {
-                        parent.decls[name] = [];
+                    if (!parent.type_decls)
+                        parent.type_decls = {};
+                    if (!api_hasProperty(parent.type_decls, name)) {
+                        parent.type_decls[name] = [];
                     }
-                    (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[name], node);
+                    else if (parent.type_decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == node)) {
+                        break;
+                    }
+                    parent.type_decls[name].push(node.type === "EnumDeclaration"
+                        ? node
+                        : {
+                            type: "TypedefDeclaration",
+                            node,
+                            name,
+                            fullName: parent.fullName + "." + name,
+                        });
                     break;
                 }
                 case "VariableDeclaration": {
@@ -1323,13 +1708,23 @@ function api_collectNamespaces(ast, stateIn) {
                     if (!parent.decls)
                         parent.decls = {};
                     const decls = parent.decls;
+                    const stack = state.stack.slice();
                     node.declarations.forEach((decl) => {
                         const name = api_variableDeclarationName(decl.id);
                         if (!api_hasProperty(decls, name)) {
                             decls[name] = [];
                         }
+                        else if (decls[name].find((n) => (api_isStateNode(n) ? n.node : n) == decl)) {
+                            return;
+                        }
                         decl.kind = node.kind;
-                        (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], decl);
+                        (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], {
+                            type: "VariableDeclarator",
+                            node: decl,
+                            name,
+                            fullName: parent.fullName + "." + name,
+                            stack,
+                        });
                         if (node.kind == "const") {
                             if (!api_hasProperty(state.index, name)) {
                                 state.index[name] = [];
@@ -1340,6 +1735,7 @@ function api_collectNamespaces(ast, stateIn) {
                     break;
                 }
                 case "EnumStringBody": {
+                    state.inType = false;
                     const [parent] = state.stack.slice(-1);
                     const values = parent.decls || (parent.decls = {});
                     let prev = -1;
@@ -1400,12 +1796,28 @@ function api_collectNamespaces(ast, stateIn) {
             let ret;
             if (state.shouldExclude && state.shouldExclude(node)) {
                 // delete the node.
-                return false;
+                ret = false;
             }
-            if (state.post)
-                ret = state.post(node, state);
-            if (state.stack.slice(-1).pop()?.node === node) {
-                state.stack.pop();
+            else {
+                const type = node.type;
+                if (state.post)
+                    ret = state.post(node, state);
+                switch (type) {
+                    case "TypeSpecList":
+                    case "TypedefDeclaration":
+                    case "EnumDeclaration":
+                        state.inType = false;
+                        break;
+                    case "EnumStringBody":
+                        state.inType = true;
+                        break;
+                }
+                if (state.stack.slice(-1).pop()?.node === node) {
+                    state.stack.pop();
+                }
+            }
+            if (ret === false) {
+                state.removeNodeComments(node, ast);
             }
             return ret;
         }
@@ -1500,22 +1912,28 @@ function formatAst(node, monkeyCSource = null) {
     });
 }
 function handleException(state, node, exception) {
-    let message;
     try {
         const fullName = state.stack
             .map((e) => e.name)
-            .concat("name" in node && typeof node.name === "string" ? node.name : null)
+            .concat("name" in node && typeof node.name === "string" ? node.name : undefined)
             .filter((e) => e != null)
             .join(".");
         const location = node.loc && node.loc.source
             ? `${node.loc.source}:${node.start || 0}:${node.end || 0}`
             : "<unknown>";
-        message = `Got exception \`${Object.prototype.toString.call(exception)}' while processing node ${fullName}:${node.type} from ${location}`;
+        const message = `Got exception \`${exception instanceof Error
+            ? exception.message
+            : Object.prototype.toString.call(exception)}' while processing node ${fullName}:${node.type} from ${location}`;
+        if (exception instanceof Error) {
+            exception.message = message;
+        }
+        else {
+            exception = new Error(message);
+        }
     }
-    catch {
+    finally {
         throw exception;
     }
-    throw new Error(message);
 }
 
 })();