@markw65/monkeyc-optimizer 1.0.19 → 1.0.22

package/build/optimizer.cjs

@@ -10784,11 +10784,11 @@ function launchSimulator() {
         child.unref();
     });
 }
-function simulateProgram(prg, device, test) {
+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, (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(() => { }));
 }
 
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
@@ -10853,23 +10853,32 @@ 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 +10890,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;
@@ -10977,27 +10988,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 +11037,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 +11083,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 +11100,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 +11125,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 +11167,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 +11183,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);
@@ -11292,23 +11302,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 +11330,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 +11370,85 @@ 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;
+        }
+        return null;
+    };
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
+    delete state.pre;
+}
+
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
@@ -11367,43 +11456,24 @@ 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 +11505,9 @@ function collectClassInfo(state) {
                 elm.decls[name] = elm.superClass;
             }
         }
+        else if (elm !== object[0]) {
+            elm.superClass = object;
+        }
     });
     const markOverrides = (cls, scls) => {
         if (scls === true)
@@ -11487,22 +11560,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 +11593,37 @@ async function analyze(fnMap) {
             }
             return false;
         },
-        post(node, state) {
+        pre(node, state) {
             switch (node.type) {
                 case "FunctionDeclaration":
+                    if (markApi) {
+                        node.body = null;
+                        break;
+                    }
+                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 +11636,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(([k, 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 +11667,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 +11686,7 @@ function getLiteralFromDecls(decls) {
             }
         }
         return false;
-    })) {
+    }))) {
         return result;
     }
     return null;
@@ -11804,14 +11890,30 @@ function evaluateFunction(func, args) {
         return false;
     }
 }
-async function optimizeMonkeyC(fnMap) {
+function markFunctionCalled(state, func) {
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, func.id.name)) {
+        state.calledFunctions[func.id.name] = [func];
+        return;
+    }
+    (0,external_util_cjs_namespaceObject.pushUnique)(state.calledFunctions[func.id.name], func);
+}
+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];
         }
@@ -11819,13 +11921,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);
@@ -11836,7 +11941,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];
@@ -11852,8 +11957,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")
@@ -11944,6 +12049,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,
@@ -12013,10 +12149,7 @@ async function optimizeMonkeyC(fnMap) {
                         used = checkInherited(parent, node.id.name);
                     }
                     if (used) {
-                        if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, node.id.name)) {
-                            state.calledFunctions[node.id.name] = [];
-                        }
-                        state.calledFunctions[node.id.name].push(node);
+                        markFunctionCalled(state, node);
                     }
                 }
             }
@@ -12029,8 +12162,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":
@@ -12040,7 +12172,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":
@@ -12055,15 +12187,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 === "=" &&
@@ -12075,7 +12203,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") {
@@ -12087,21 +12215,20 @@ 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);
                         }
                     }
                 }
                 else {
                     const ret = unused(node.expression, true);
                     if (ret) {
-                        return ret;
+                        return ret
+                            .map((r) => replace(r, r))
+                            .flat(1)
+                            .filter((s) => !!s);
                     }
                 }
                 break;
@@ -12111,10 +12238,18 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
+    state.calledFunctions = {};
+    state.exposed = {};
+    Object.values(fnMap).forEach((f) => {
+        (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
+    });
     delete state.pre;
     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;
@@ -12139,19 +12274,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": {
@@ -12174,6 +12314,19 @@ async function optimizeMonkeyC(fnMap) {
                     return false;
                 }
                 break;
+            case "ClassDeclaration":
+            case "ModuleDeclaration":
+                // none of the attributes means anything on classes and
+                // modules, and the new compiler complains about some
+                // of them. Just drop them all.
+                if (node.attrs && node.attrs.access) {
+                    if (node.attrs.attributes) {
+                        delete node.attrs.access;
+                    }
+                    else {
+                        delete node.attrs;
+                    }
+                }
         }
         return null;
     };
@@ -12189,7 +12342,12 @@ async function optimizeMonkeyC(fnMap) {
     return state.diagnostics;
 }
 function optimizeCall(state, node, context) {
-    const [name, callees] = state.lookup(node.callee);
+    const [name, results] = state.lookupNonlocal(node.callee);
+    const callees = results &&
+        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) ||
@@ -12224,32 +12382,34 @@ function optimizeCall(state, node, context) {
             }
         }
     }
-    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
-        state.calledFunctions[name] = [];
-    }
-    callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && (0,external_util_cjs_namespaceObject.pushUnique)(state.calledFunctions[name], c.node));
+    callees.forEach((c) => markFunctionCalled(state, c.node));
     return null;
 }
 
 ;// 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;
@@ -12259,35 +12419,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) => {
         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;
     });
@@ -12675,6 +12879,7 @@ const configOptionsToCheck = [
     "ignoredExcludeAnnotations",
     "ignoredAnnotations",
     "ignoredSourcePaths",
+    "checkInvalidSymbols",
 ];
 /**
  * @param {BuildConfig} config
@@ -12726,21 +12931,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 && 1654554780017 < opt_time) {
+        if (source_time < opt_time && 1655479110007 < 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) => {
@@ -12775,7 +12980,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 };
 }
 /**