@markw65/monkeyc-optimizer 1.0.20 → 1.0.23

package/build/optimizer.cjs

@@ -9858,7 +9858,7 @@ const external_util_cjs_namespaceObject = require("./util.cjs");
 async function build_project(product, options, lineCallback) {
     const { workspace, program, jungleFiles, developerKeyPath, simulatorBuild, releaseBuild, testBuild, compilerOptions, compilerWarnings, typeCheckLevel, returnCommand, } = options;
     const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
-    let extraArgs = [];
+    const extraArgs = [];
     if (compilerOptions) {
         extraArgs.push(...compilerOptions.split(/\s+/));
     }
@@ -9894,6 +9894,9 @@ async function build_project(product, options, lineCallback) {
     else if (testBuild) {
         throw new Error("Building for tests requires a device to build for!");
     }
+    if (!program || !jungleFiles || !developerKeyPath || !workspace) {
+        throw new Error("Required arguments were missing!");
+    }
     const exe = external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "monkeyc.bat" : "monkeyc");
     const args = [
         ["-o", program],
@@ -9928,9 +9931,8 @@ async function readManifest(manifest) {
     return (0,xml2js.parseStringPromise)(data.toString(), { trim: true });
 }
 async function writeManifest(filename, xml) {
-    let builder = new xml2js.Builder();
-    let text = builder.buildObject(xml);
-    return promises_namespaceObject.writeFile(filename, text);
+    const builder = new xml2js.Builder();
+    return promises_namespaceObject.writeFile(filename, builder.buildObject(xml));
 }
 function manifestProducts(manifest) {
     const app = manifest["iq:manifest"]["iq:application"] ||
@@ -10228,7 +10230,7 @@ function resolve_node_by_path(state, path) {
         }
         if (!s[n] && s["."]) {
             const sdot = s["."];
-            let resolved = resolve_node_list(state, sdot);
+            const resolved = resolve_node_list(state, sdot);
             if (!resolved.length)
                 return undefined;
             const r = resolved[0][n];
@@ -10317,11 +10319,11 @@ async function resolve_literals(qualifier, default_source, deviceInfo) {
                 return resolve_file_list(v.values);
             }
             let resolved = resolve_filename(v, default_source);
-            if (/[*?\[\]\{\}]/.test(resolved)) {
+            if (/[*?[\]{}]/.test(resolved)) {
                 // Jungle files can contain "./**.mc" which is supposed to match
                 // any mc file under "./". The standard way to express that
                 // is "./**/*.mc", which is what glob expects, so translate.
-                resolved = resolved.replace(/[\\\/]\*\*([^\\\/])/g, "/**/*$1");
+                resolved = resolved.replace(/[\\/]\*\*([^\\/])/g, "/**/*$1");
                 const match = await (0,external_util_cjs_namespaceObject.globa)(resolved);
                 return match.length ? resolved : null;
             }
@@ -10595,7 +10597,7 @@ function resolve_barrel(barrel, barrelDir, products, options) {
         const sha1 = external_crypto_namespaceObject.createHash("sha1")
             .update(barrel, "binary")
             .digest("base64")
-            .replace(/[\/=+]/g, "");
+            .replace(/[/=+]/g, "");
         const localPath = external_path_.resolve(barrelDir, `${external_path_.basename(barrel, ".barrel")}-${sha1}`);
         rawBarrel = external_path_.resolve(localPath, "barrel.jungle");
         promise = promise.then(() => promises_namespaceObject.stat(localPath)
@@ -10745,7 +10747,9 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
             targets.push({ product, qualifier, shape });
             return resolve_barrels(product, qualifier, barrels, products, options);
         })
-            .then(() => { });
+            .then(() => {
+            return;
+        });
     };
     products.forEach((product) => {
         if ((0,external_api_cjs_namespaceObject.hasProperty)(state, product)) {
@@ -10788,11 +10792,151 @@ function simulateProgram(prg, device, test = false, logger) {
     const args = [prg, device];
     if (test)
         args.push("-t");
-    return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", "monkeydo"), args, logger || ((line) => console.log(line))).then(() => { }));
+    return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", "monkeydo"), args, logger || ((line) => console.log(line))).then(() => {
+        return;
+    }));
+}
+
+;// 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 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 = 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 = 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: ./src/variable-renamer.ts
 
+
 function renameVariable(state, locals, declName) {
     const map = locals.map;
     if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, declName))
@@ -10809,7 +10953,7 @@ function renameVariable(state, locals, declName) {
         // more conflicts
         locals.inners = {};
         const inners = locals.inners;
-        (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
+        traverseAst(locals.node, (node) => {
             if (node.type === "VariableDeclarator") {
                 inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
             }
@@ -10849,27 +10993,37 @@ function 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;
@@ -10881,11 +11035,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;
@@ -10905,25 +11061,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) => [(0,external_api_cjs_namespaceObject.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)
-    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
-        return Object.entries(node)
-            .filter((kv) => Array.isArray(kv[1])
-            ? kv[1].length !== 0 && (0,external_api_cjs_namespaceObject.hasProperty)(kv[1][0], "type")
-            : (0,external_api_cjs_namespaceObject.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": {
@@ -10977,27 +11120,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_") &&
-                    (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7)))))) {
+                    !(0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7)))))) {
         return true;
     }
     return false;
 }
 function shouldInline(state, func, call, context) {
+    if (state.inlining)
+        return false;
     let autoInline = false;
     let inlineAsExpression = false;
     const args = call.arguments;
@@ -11030,6 +11169,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)
@@ -11075,7 +11215,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": {
@@ -11092,12 +11232,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) {
@@ -11116,6 +11257,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     finally {
         state.pre = pre;
         state.post = post;
+        delete state.inlining;
     }
 }
 function unused(expression, top) {
@@ -11157,7 +11299,7 @@ function unused(expression, top) {
             },
         ];
 }
-function diagnostic(state, loc, message) {
+function diagnostic(state, loc, message, type = "INFO") {
     if (!loc || !loc.source)
         return;
     const source = loc.source;
@@ -11173,7 +11315,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);
@@ -11197,7 +11339,7 @@ function inlineWithArgs(state, func, call, context) {
         }
     }
     else {
-        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+        traverseAst(func.node.body, (node) => {
             node.type === "ReturnStatement" && retStmtCount++;
         });
         if (retStmtCount > 1) {
@@ -11292,23 +11434,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 && (0,external_api_cjs_namespaceObject.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 ((0,external_api_cjs_namespaceObject.isStateNode)(sn) && sn.fullName) {
             return sn.fullName;
         }
         return "";
-    });
+    }))
+        .flat();
     if (prefixes.length &&
         prefixes[0].startsWith("$.") &&
         prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
@@ -11318,9 +11462,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 && (0,external_api_cjs_namespaceObject.sameLookupResult)(original, results)) {
                 found = true;
                 return current;
             }
@@ -11360,6 +11502,99 @@ function fixNodeScope(state, lookupNode, nodeStack) {
     return null;
 }
 
+;// CONCATENATED MODULE: ./src/visitor.ts
+
+function 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
 
 
@@ -11367,43 +11602,25 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 
 
 
-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 (!(0,external_api_cjs_namespaceObject.hasProperty)(decls, name))
-                decls[name] = [];
-            module.forEach((m) => {
-                if ((0,external_api_cjs_namespaceObject.isStateNode)(m) && m.type == "ModuleDeclaration") {
-                    (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], m);
-                    if (!parent.type_decls)
-                        parent.type_decls = {};
-                    const tdecls = parent.type_decls;
-                    if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
-                        tdecls[name] = [];
-                    (0,external_util_cjs_namespaceObject.pushUnique)(tdecls[name], m);
-                    if (node.type == "ImportModule" && m.type_decls) {
-                        Object.entries(m.type_decls).forEach(([name, decls]) => {
-                            if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
-                                tdecls[name] = [];
-                            decls.forEach((decl) => (0,external_util_cjs_namespaceObject.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) => (0,external_api_cjs_namespaceObject.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) => (0,external_api_cjs_namespaceObject.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) {
@@ -11435,6 +11652,9 @@ function collectClassInfo(state) {
                 elm.decls[name] = elm.superClass;
             }
         }
+        else if (elm !== object[0]) {
+            elm.superClass = object;
+        }
     });
     const markOverrides = (cls, scls) => {
         if (scls === true)
@@ -11464,7 +11684,9 @@ function getFileSources(fnMap) {
         return (value.monkeyCSource ||
             promises_namespaceObject.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]) => {
@@ -11487,22 +11709,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")
@@ -11519,45 +11742,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 (0,external_api_cjs_namespaceObject.getApiMapping)(preState);
+    await (0,external_api_cjs_namespaceObject.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 ((0,external_api_cjs_namespaceObject.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;
@@ -11570,8 +11786,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 = (0,external_api_cjs_namespaceObject.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) {
@@ -11581,11 +11817,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);
@@ -11600,7 +11836,7 @@ function getLiteralFromDecls(decls) {
             }
         }
         return false;
-    })) {
+    }))) {
         return result;
     }
     return null;
@@ -11763,7 +11999,7 @@ function evaluateFunction(func, args) {
         ? JSON.parse(JSON.stringify(func.body))
         : func.body;
     try {
-        (0,external_api_cjs_namespaceObject.traverseAst)(body, (node) => {
+        traverseAst(body, (node) => {
             switch (node.type) {
                 case "BlockStatement":
                 case "ReturnStatement":
@@ -11811,14 +12047,23 @@ function markFunctionCalled(state, func) {
     }
     (0,external_util_cjs_namespaceObject.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];
         }
@@ -11826,13 +12071,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);
@@ -11843,7 +12091,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];
@@ -11859,8 +12107,8 @@ async function optimizeMonkeyC(fnMap) {
         if ((0,external_api_cjs_namespaceObject.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")
@@ -11890,7 +12138,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);
@@ -11922,6 +12170,7 @@ async function optimizeMonkeyC(fnMap) {
                     }
                 }
                 return null;
+            }
             case "EnumDeclaration":
                 return false;
             case "ForStatement": {
@@ -11951,6 +12200,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 = (0,external_api_cjs_namespaceObject.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,
@@ -12033,8 +12313,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":
@@ -12044,7 +12323,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":
@@ -12059,15 +12338,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 === "=" &&
@@ -12079,7 +12354,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") {
@@ -12091,14 +12366,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);
                         }
                     }
                 }
@@ -12106,12 +12377,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;
@@ -12130,6 +12398,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;
@@ -12154,19 +12425,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": {
@@ -12189,11 +12465,24 @@ 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;
     };
     Object.values(fnMap).forEach((f) => {
-        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
+        traverseAst(f.ast, undefined, (node) => {
             const ret = cleanup(node);
             if (ret === false) {
                 state.removeNodeComments(node, f.ast);
@@ -12204,9 +12493,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) ||
@@ -12247,23 +12539,29 @@ function optimizeCall(state, node, context) {
 
 ;// CONCATENATED MODULE: ./src/pragma-checker.ts
 
-function pragmaChecker(ast) {
+
+function pragmaChecker(ast, diagnostics) {
     const comments = ast.comments;
     if (!comments)
         return;
+    diagnostics = diagnostics
+        ?.slice()
+        .sort((d1, d2) => d1.loc.start < d2.loc.start ? -1 : d1.loc.start == d2.loc.start ? 0 : 1);
+    let diagIndex = 0;
     let index = -1;
     let comment;
     let matchers;
     const next = () => {
         while (++index < comments.length) {
             comment = comments[index];
-            let match = comment.value.match(/^\s*@match\s+(.+)/);
+            let match = comment.value.match(/^\s*@(match|expect)\s+(.+)/);
             if (!match)
                 continue;
-            let str = match[1];
+            const kind = match[1];
+            let str = match[2];
             matchers = [];
             while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
-                matchers.push({ quote: match[1], needle: match[2] });
+                matchers.push({ kind, quote: match[1], needle: match[2] });
                 str = str.substring(match[0].length);
                 if (!str.length)
                     break;
@@ -12273,35 +12571,79 @@ function pragmaChecker(ast) {
             if (!matchers.length) {
                 match = str.match(/^(\S+)\s+$/);
                 if (match) {
-                    matchers.push({ quote: '"', needle: match[1] });
+                    matchers.push({ kind, quote: '"', needle: match[1] });
                     break;
                 }
             }
             throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
         }
     };
+    const matcher = (quote, needle, haystack) => {
+        if (quote == '"') {
+            return haystack.includes(needle);
+        }
+        const re = new RegExp(needle);
+        return re.test(haystack);
+    };
     next();
-    (0,external_api_cjs_namespaceObject.traverseAst)(ast, (node) => {
+    traverseAst(ast, (node) => {
         if (index >= comments.length)
             return false;
         if (node.start && node.start >= (comment.end || Infinity)) {
-            const { quote, needle } = matchers.shift();
-            const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/[\r\n]/g, " ");
-            let found = false;
-            if (quote == '"') {
-                found = haystack.includes(needle);
-            }
-            else {
-                const re = new RegExp(needle);
-                found = re.test(haystack);
+            const { kind, quote, needle } = matchers.shift();
+            if (kind === "match") {
+                if (!matcher(quote, needle, (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/([\r\n]|\s)+/g, " "))) {
+                    throw new Error(`Didn't find '${needle}' at ${comment.loc.source}:${comment.loc.start.line}`);
+                }
             }
-            if (!found) {
-                throw new Error(`Didn't find '${needle}' at ${comment.loc.source}:${comment.loc.start.line}`);
+            else if (kind === "expect") {
+                const locCmp = (a, b) => {
+                    if (!b)
+                        return -1;
+                    if (a.start.line < b.start.line)
+                        return -1;
+                    if (a.start.line === b.start.line &&
+                        a.start.column < b.start.column) {
+                        return -1;
+                    }
+                    if (a.end.line > b.end.line)
+                        return 1;
+                    if (a.end.line === b.end.line && a.end.column >= b.end.column) {
+                        return 1;
+                    }
+                    return 0;
+                };
+                let found = false;
+                if (diagnostics) {
+                    while (true) {
+                        if (diagIndex >= diagnostics.length) {
+                            diagnostics = null;
+                            break;
+                        }
+                        const diag = diagnostics[diagIndex];
+                        const cmp = locCmp(diag.loc, node.loc);
+                        if (cmp > 0) {
+                            break;
+                        }
+                        diagIndex++;
+                        if (cmp < 0)
+                            continue;
+                        if (matcher(quote, needle, diag.message)) {
+                            found = true;
+                            diag.type = "INFO";
+                        }
+                    }
+                }
+                if (!found) {
+                    throw new Error(`Missing error message '${needle} at ${comment.loc.source}:${comment.loc.start.line}`);
+                }
             }
-            if (!matchers.length) {
-                next();
+            if (matchers.length) {
+                // if we're checking a series of nodes, we need
+                // to skip over this one.
+                return false;
             }
-            return false;
+            next();
         }
         return null;
     });
@@ -12323,7 +12665,7 @@ function pragmaChecker(ast) {
 
 
 function relative_path_no_dotdot(relative) {
-    return relative.replace(/^(\.\.[\\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
+    return relative.replace(/^(\.\.[\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
 }
 async function getVSCodeSettings(path) {
     try {
@@ -12455,7 +12797,7 @@ async function createLocalBarrels(targets, options) {
             const sha1 = external_crypto_namespaceObject.createHash("sha1")
                 .update(rawBarrelDir, "binary")
                 .digest("base64")
-                .replace(/[\/=+]/g, "");
+                .replace(/[/=+]/g, "");
             const optBarrelDir = external_path_.resolve(barrelDir, `${barrel}-${sha1}`);
             if (!(0,external_api_cjs_namespaceObject.hasProperty)(optBarrels, barrel)) {
                 optBarrels[barrel] = {
@@ -12503,7 +12845,9 @@ async function generateOptimizedProject(options) {
         }
         return {
             jungleFiles: config.jungleFiles,
+            xml,
             program: external_path_.basename(external_path_.dirname(manifest)),
+            hasTests: !!config.testBuild,
         };
     }
     let dropBarrels = false;
@@ -12604,7 +12948,7 @@ async function generateOptimizedProject(options) {
         }
         const prefix = `${product}.`;
         process_field(prefix, qualifier, "sourcePath", (s) => external_path_.join(group.dir, "source", relative_path_no_dotdot(external_path_.relative(workspace, s)))
-            .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1"));
+            .replace(/([\\/]\*\*)[\\/]\*/g, "$1"));
         if (group.optimizerConfig.optBarrels) {
             parts.push(`${prefix}barrelPath = ${Object.values(group.optimizerConfig.optBarrels)
                 .map((value) => `[${value.jungleFiles
@@ -12618,7 +12962,7 @@ async function generateOptimizedProject(options) {
                 .map(([barrel, resolvedBarrel]) => {
                 const root = external_path_.dirname(resolvedBarrel.jungles[0]);
                 return (resolvedBarrel.qualifier.sourcePath || []).map((s) => external_path_.join(group.dir, "barrels", barrel, external_path_.relative(root, s))
-                    .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1"));
+                    .replace(/([\\/]\*\*)[\\/]\*/g, "$1"));
             })
                 .flat()
                 .sort()
@@ -12689,6 +13033,7 @@ const configOptionsToCheck = [
     "ignoredExcludeAnnotations",
     "ignoredAnnotations",
     "ignoredSourcePaths",
+    "checkInvalidSymbols",
 ];
 /**
  * @param {BuildConfig} config
@@ -12740,21 +13085,21 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1654708837029 < opt_time) {
+        if (source_time < opt_time && 1655677006664 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
     await promises_namespaceObject.rm(output, { recursive: true, force: true });
     await promises_namespaceObject.mkdir(output, { recursive: true });
-    const diagnostics = await optimizeMonkeyC(fnMap);
-    return Promise.all(Object.values(fnMap).map(async (info) => {
+    const diagnostics = await optimizeMonkeyC(fnMap, Object.keys(buildConfig.barrelMap || {}), config);
+    return Promise.all(Object.entries(fnMap).map(async ([inFile, info]) => {
         const name = info.output;
         const dir = external_path_.dirname(name);
         await promises_namespaceObject.mkdir(dir, { recursive: true });
         const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(info.ast, info.monkeyCSource);
         await promises_namespaceObject.writeFile(name, opt_source);
         if (config.checkBuildPragmas) {
-            pragmaChecker(info.ast);
+            pragmaChecker(info.ast, diagnostics?.[inFile]);
         }
         return info.hasTests;
     })).then((results) => {
@@ -12789,7 +13134,13 @@ async function getProjectAnalysis(targets, analysis, options) {
     if (!(await getFileASTs(fnMap))) {
         return { fnMap, paths };
     }
-    const state = await analyze(fnMap);
+    const barrelObj = {};
+    targets.forEach((target) => {
+        if (target.qualifier.barrelMap) {
+            Object.keys(target.qualifier.barrelMap).forEach((key) => (barrelObj[key] = true));
+        }
+    });
+    const state = await analyze(fnMap, Object.keys(barrelObj), options);
     return { fnMap: fnMap, paths, state };
 }
 /**