@markw65/monkeyc-optimizer 1.0.17 → 1.0.20

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
@@ -10902,7 +10902,7 @@ function getArgSafety(state, func, args, requireAll) {
     })) {
         return false;
     }
-    if (allSafe)
+    if (allSafe && requireAll)
         return true;
     let callSeen = false;
     let ok = true;
@@ -10925,10 +10925,16 @@ function getArgSafety(state, func, args, requireAll) {
             .map(([key]) => key);
     }, (node) => {
         switch (node.type) {
+            case "AssignmentExpression":
+            case "UpdateExpression": {
+                const v = node.type == "UpdateExpression" ? node.argument : node.left;
+                if (v.type === "Identifier" && (0,external_api_cjs_namespaceObject.hasProperty)(params, v.name)) {
+                    safeArgs[params[v.name]] = null;
+                }
+            }
+            // fall through
             case "CallExpression":
             case "NewExpression":
-            case "AssignmentExpression":
-            case "UpdateExpression":
                 callSeen = true;
                 break;
             case "Identifier":
@@ -10977,9 +10983,24 @@ var InlineStatus;
     InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
     InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
 })(InlineStatus || (InlineStatus = {}));
-function shouldInline(state, func, args) {
+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" &&
+            (attr.argument.name === "inline" ||
+                (attr.argument.name.startsWith("inline_") &&
+                    (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7)))))) {
+        return true;
+    }
+    return false;
+}
+function shouldInline(state, func, call, context) {
     let autoInline = false;
     let inlineAsExpression = false;
+    const args = call.arguments;
     if (func.node.body &&
         func.node.body.body.length === 1 &&
         func.node.body.body[0].type === "ReturnStatement" &&
@@ -10989,39 +11010,30 @@ function shouldInline(state, func, args) {
         autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
     }
     if (autoInline === 1) {
-        return InlineStatus.AsExpression;
+        return true;
     }
-    const excludeAnnotations = (func.node.loc?.source &&
-        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
-        {};
-    const inlineRequested = func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
-            (attr.argument.name === "inline" ||
-                (attr.argument.name.startsWith("inline_") &&
-                    (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7)))));
-    if (autoInline || inlineRequested) {
-        return inlineAsExpression && canInline(state, func, args)
-            ? InlineStatus.AsExpression
-            : InlineStatus.AsStatement;
+    const requested = inlineRequested(state, func);
+    if (autoInline || requested) {
+        if (inlineAsExpression) {
+            if (canInline(state, func, args)) {
+                return true;
+            }
+        }
+        if (!context && requested) {
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+        }
+        return context != null;
     }
-    return InlineStatus.Never;
+    return false;
 }
 function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
-    if (!params) {
-        const safeArgs = getArgSafety(state, func, call.arguments, false);
-        params = Object.fromEntries(func.node.params.map((param, i) => {
-            const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
-                ? i
-                : -1;
-            const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
-            return [name, argnum];
-        }));
-    }
+    let failed = false;
     const pre = state.pre;
     const post = state.post;
     try {
         state.pre = (node) => {
+            if (failed)
+                return [];
             node.start = call.start;
             node.end = call.end;
             node.loc = call.loc;
@@ -11033,6 +11045,11 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                 const { map } = locals;
                 if (!map)
                     throw new Error("No local variable map!");
+                // We still need to keep track of every local name that was
+                // already in use, but we don't want to use any of its renames.
+                // We also want to know whether a local is from the function being
+                // inlined, or the calling function, so set every element to false.
+                Object.keys(map).forEach((key) => (map[key] = false));
                 const declarations = func.node.params
                     .map((param, i) => {
                     const paramName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
@@ -11057,6 +11074,8 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
             return result;
         };
         state.post = (node) => {
+            if (failed)
+                return null;
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -11071,22 +11090,28 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     }
                     replacement = fixNodeScope(state, node, func.stack);
                     if (!replacement) {
-                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                        failed = true;
+                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+                        return null;
                     }
                     break;
                 }
             }
             return post(replacement || node, state) || replacement;
         };
-        return state.traverse(root) || null;
-    }
-    catch (ex) {
-        if (ex instanceof Error) {
-            if (ex.message.startsWith("Inliner: ")) {
-                return null;
-            }
+        let ret = state.traverse(root);
+        if (failed) {
+            return null;
+        }
+        if (ret === null) {
+            ret = root;
         }
-        throw ex;
+        if (!ret) {
+            inlineDiagnostic(state, func, call, `Internal error`);
+            return null;
+        }
+        inlineDiagnostic(state, func, call, null);
+        return ret;
     }
     finally {
         state.pre = pre;
@@ -11109,7 +11134,16 @@ function unused(expression, top) {
         case "UnaryExpression":
             return unused(expression.argument);
         case "MemberExpression":
-            return unused(expression.object).concat(unused(expression.property));
+            if (expression.computed) {
+                return unused(expression.object).concat(unused(expression.property));
+            }
+            return unused(expression.object);
+        case "ArrayExpression":
+            return expression.elements.map((e) => unused(e)).flat(1);
+        case "ObjectExpression":
+            return expression.properties
+                .map((p) => unused(p.key).concat(unused(p.value)))
+                .flat(1);
     }
     return top
         ? null
@@ -11117,30 +11151,98 @@ function unused(expression, top) {
             {
                 type: "ExpressionStatement",
                 expression,
+                start: expression.start,
+                end: expression.end,
+                loc: expression.loc,
             },
         ];
 }
-function inlineWithArgs(state, func, call) {
+function diagnostic(state, loc, message) {
+    if (!loc || !loc.source)
+        return;
+    const source = loc.source;
+    if (!state.diagnostics)
+        state.diagnostics = {};
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.diagnostics, source)) {
+        if (!message)
+            return;
+        state.diagnostics[source] = [];
+    }
+    const diags = state.diagnostics[source];
+    let index = diags.findIndex((item) => item.loc === loc);
+    if (message) {
+        if (index < 0)
+            index = diags.length;
+        diags[index] = { type: "INFO", loc, message };
+    }
+    else if (index >= 0) {
+        diags.splice(index, 1);
+    }
+}
+function inlineDiagnostic(state, func, call, message) {
+    if (inlineRequested(state, func)) {
+        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+    }
+}
+function inlineWithArgs(state, func, call, context) {
     if (!func.node || !func.node.body) {
         return null;
     }
     let retStmtCount = 0;
-    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
-        node.type === "ReturnStatement" && retStmtCount++;
-    });
-    if (retStmtCount > 1 ||
-        (retStmtCount === 1 &&
-            func.node.body.body.slice(-1)[0].type !== "ReturnStatement")) {
-        return null;
+    if (context.type === "ReturnStatement") {
+        const last = func.node.body.body.slice(-1)[0];
+        if (!last || last.type !== "ReturnStatement") {
+            inlineDiagnostic(state, func, call, "Function didn't end with a return statement");
+            return null;
+        }
+    }
+    else {
+        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+            node.type === "ReturnStatement" && retStmtCount++;
+        });
+        if (retStmtCount > 1) {
+            inlineDiagnostic(state, func, call, "Function had more than one return statement");
+        }
+        else if (context.type === "AssignmentExpression" && retStmtCount !== 1) {
+            inlineDiagnostic(state, func, call, "Function did not have a return statement");
+            return null;
+        }
+        if (retStmtCount === 1) {
+            const last = func.node.body.body.slice(-1)[0];
+            if (!last ||
+                last.type !== "ReturnStatement" ||
+                (context.type === "AssignmentExpression" && !last.argument)) {
+                inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
+                return null;
+            }
+        }
     }
     const body = JSON.parse(JSON.stringify(func.node.body));
-    processInlineBody(state, func, call, body, func.node.params.length ? false : true);
-    if (retStmtCount) {
+    const safeArgs = getArgSafety(state, func, call.arguments, false);
+    const params = Object.fromEntries(func.node.params.map((param, i) => {
+        const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
+            ? i
+            : -1;
+        const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
+        return [name, argnum];
+    }));
+    if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
+        return null;
+    }
+    diagnostic(state, call.loc, null);
+    if (context.type !== "ReturnStatement" && retStmtCount) {
         const last = body.body[body.body.length - 1];
         if (last.type != "ReturnStatement") {
             throw new Error("ReturnStatement got lost!");
         }
-        if (last.argument) {
+        if (context.type === "AssignmentExpression") {
+            context.right = last.argument;
+            body.body[body.body.length - 1] = {
+                type: "ExpressionStatement",
+                expression: context,
+            };
+        }
+        else if (last.argument) {
             const side_exprs = unused(last.argument);
             body.body.splice(body.body.length - 1, 1, ...side_exprs);
         }
@@ -11150,13 +11252,13 @@ function inlineWithArgs(state, func, call) {
     }
     return body;
 }
-function inlineFunction(state, func, call, inlineStatus) {
-    if (inlineStatus == InlineStatus.AsStatement) {
-        return inlineWithArgs(state, func, call);
+function inlineFunction(state, func, call, context) {
+    if (context) {
+        return inlineWithArgs(state, func, call, context);
     }
     const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
     const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
-    return processInlineBody(state, func, call, retArg, true, params) || retArg;
+    return processInlineBody(state, func, call, retArg, true, params);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -11171,13 +11273,14 @@ function applyTypeIfNeeded(node) {
 }
 function fixNodeScope(state, lookupNode, nodeStack) {
     if (lookupNode.type === "Identifier") {
-        for (let i = state.stack.length; --i > nodeStack.length;) {
-            const si = state.stack[i];
-            if ((0,external_api_cjs_namespaceObject.hasProperty)(si.decls, lookupNode.name)) {
-                // its a local from the inlined function.
-                // Nothing to do.
-                return lookupNode;
-            }
+        const locals = state.localsStack[state.localsStack.length - 1];
+        const { map } = locals;
+        if (!map)
+            throw new Error("No local variable map!");
+        if ((0,external_api_cjs_namespaceObject.hasProperty)(map, lookupNode.name) && map[lookupNode.name] !== false) {
+            // map[name] !== false means its an entry that was created during inlining
+            // so its definitely one of our locals.
+            return lookupNode;
         }
     }
     const [, original] = state.lookup(lookupNode, null, nodeStack);
@@ -11650,13 +11753,15 @@ function optimizeNode(node) {
     return null;
 }
 function evaluateFunction(func, args) {
-    if (args && args.length != func.params.length) {
+    if (!func.body || (args && args.length != func.params.length)) {
         return false;
     }
     const paramValues = args &&
         Object.fromEntries(func.params.map((p, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(p), args[i]]));
     let ret = null;
-    const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+    const body = args
+        ? JSON.parse(JSON.stringify(func.body))
+        : func.body;
     try {
         (0,external_api_cjs_namespaceObject.traverseAst)(body, (node) => {
             switch (node.type) {
@@ -11699,6 +11804,13 @@ function evaluateFunction(func, args) {
         return false;
     }
 }
+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) {
     const state = {
         ...(await analyze(fnMap)),
@@ -11857,7 +11969,7 @@ async function optimizeMonkeyC(fnMap) {
                 if (map) {
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
                         const name = map[node.name];
-                        if (name !== true) {
+                        if (typeof name === "string") {
                             node.name = name;
                         }
                     }
@@ -11908,10 +12020,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);
                     }
                 }
             }
@@ -11948,27 +12057,61 @@ async function optimizeMonkeyC(fnMap) {
                     return node.body;
                 }
                 break;
+            case "ReturnStatement":
+                if (node.argument && node.argument.type === "CallExpression") {
+                    return optimizeCall(state, node.argument, node);
+                }
+                break;
             case "CallExpression": {
-                const ret = optimizeCall(state, node, false);
+                const ret = optimizeCall(state, node, null);
                 if (ret) {
                     replace(node, ret);
                 }
                 break;
             }
+            case "AssignmentExpression":
+                if (node.operator === "=" &&
+                    node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    return { type: "Literal", value: null, raw: "null" };
+                }
+                break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    const ret = optimizeCall(state, node.expression, true);
-                    if (ret) {
-                        if (ret.type === "BlockStatement") {
-                            return ret;
+                    return optimizeCall(state, node.expression, node);
+                }
+                else if (node.expression.type === "AssignmentExpression") {
+                    if (node.expression.right.type === "CallExpression") {
+                        let ok = false;
+                        if (node.expression.left.type === "Identifier") {
+                            if ((0,external_api_cjs_namespaceObject.hasProperty)(topLocals().map, node.expression.left.type)) {
+                                ok = true;
+                            }
+                        }
+                        if (!ok && node.expression.operator == "=") {
+                            const [, result] = state.lookup(node.expression.left);
+                            ok = result != null;
+                        }
+                        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;
+                            }
                         }
-                        node.expression = ret;
                     }
                 }
                 else {
                     const ret = unused(node.expression, true);
                     if (ret) {
-                        return ret;
+                        return ret
+                            .map((s) => {
+                            const r2 = state.traverse(s);
+                            return r2 === false || r2 ? r2 : s;
+                        })
+                            .flat(1)
+                            .filter((s) => s !== false);
                     }
                 }
                 break;
@@ -11978,6 +12121,11 @@ 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) => {
@@ -12053,9 +12201,12 @@ async function optimizeMonkeyC(fnMap) {
             return ret;
         });
     });
+    return state.diagnostics;
 }
-function optimizeCall(state, node, asStatement) {
-    const [name, callees] = state.lookup(node.callee);
+function optimizeCall(state, node, context) {
+    const [name, results] = state.lookup(node.callee);
+    const callees = results &&
+        results.filter((c) => c.type === "FunctionDeclaration");
     if (!callees || !callees.length) {
         const n = name ||
             ("name" in node.callee && node.callee.name) ||
@@ -12074,7 +12225,8 @@ function optimizeCall(state, node, asStatement) {
     }
     if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
         const callee = callees[0].node;
-        if (callee.optimizable &&
+        if (!context &&
+            callee.optimizable &&
             !callee.hasOverride &&
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
             const ret = evaluateFunction(callee, node.arguments);
@@ -12082,19 +12234,14 @@ function optimizeCall(state, node, asStatement) {
                 return ret;
             }
         }
-        const inlineStatus = shouldInline(state, callees[0], node.arguments);
-        if (inlineStatus === InlineStatus.AsExpression ||
-            (asStatement && inlineStatus === InlineStatus.AsStatement)) {
-            const ret = inlineFunction(state, callees[0], node, inlineStatus);
+        if (shouldInline(state, callees[0], node, context)) {
+            const ret = inlineFunction(state, callees[0], node, context);
             if (ret) {
                 return ret;
             }
         }
     }
-    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
-        state.calledFunctions[name] = [];
-    }
-    callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && state.calledFunctions[name].push(c.node));
+    callees.forEach((c) => markFunctionCalled(state, c.node));
     return null;
 }
 
@@ -12106,12 +12253,31 @@ function pragmaChecker(ast) {
         return;
     let index = -1;
     let comment;
+    let matchers;
     const next = () => {
         while (++index < comments.length) {
             comment = comments[index];
-            if (comment.value.match(/^\s*@match\s+/)) {
+            let match = comment.value.match(/^\s*@match\s+(.+)/);
+            if (!match)
+                continue;
+            let str = match[1];
+            matchers = [];
+            while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
+                matchers.push({ quote: match[1], needle: match[2] });
+                str = str.substring(match[0].length);
+                if (!str.length)
+                    break;
+            }
+            if (!str.length)
                 break;
+            if (!matchers.length) {
+                match = str.match(/^(\S+)\s+$/);
+                if (match) {
+                    matchers.push({ quote: '"', needle: match[1] });
+                    break;
+                }
             }
+            throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
         }
     };
     next();
@@ -12119,29 +12285,23 @@ function pragmaChecker(ast) {
         if (index >= comments.length)
             return false;
         if (node.start && node.start >= (comment.end || Infinity)) {
-            let match = comment.value.match(/^\s*@match\s+([/%&#@"])(.+(?<!\\)(?:\\{2})*)\1\s+$/) || comment.value.match(/^\s*@match\s+(\S+)\s+$/);
-            if (!match) {
-                throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
-            }
+            const { quote, needle } = matchers.shift();
             const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/[\r\n]/g, " ");
             let found = false;
-            let needle = match[1];
-            if (match.length == 2) {
+            if (quote == '"') {
                 found = haystack.includes(needle);
             }
             else {
-                if (needle == '"') {
-                    found = haystack.includes((needle = match[2]));
-                }
-                else {
-                    const re = new RegExp((needle = match[2]));
-                    found = re.test(haystack);
-                }
+                const re = new RegExp(needle);
+                found = re.test(haystack);
             }
             if (!found) {
-                throw new Error(`Didn't find '${needle}' in ${comment.loc.source}:${comment.loc.start.line}`);
+                throw new Error(`Didn't find '${needle}' at ${comment.loc.source}:${comment.loc.start.line}`);
+            }
+            if (!matchers.length) {
+                next();
             }
-            next();
+            return false;
         }
         return null;
     });
@@ -12230,7 +12390,7 @@ async function buildOptimizedProject(product, options) {
             config.releaseBuild = true;
         }
     }
-    const { jungleFiles, program, hasTests } = await generateOptimizedProject(config);
+    const { jungleFiles, program, hasTests, diagnostics } = await generateOptimizedProject(config);
     config.jungleFiles = jungleFiles;
     let bin = config.buildDir || "bin";
     let name = `optimized-${program}.prg`;
@@ -12249,6 +12409,7 @@ async function buildOptimizedProject(product, options) {
         delete config.testBuild;
     return build_project(product, config).then((result) => ({
         hasTests,
+        diagnostics,
         ...result,
     }));
 }
@@ -12387,6 +12548,7 @@ async function generateOptimizedProject(options) {
         (await checkManifest(xml, targets.map((t) => t.product)))) &&
         !dropBarrels;
     let hasTests = false;
+    let diagnostics = {};
     const promises = Object.keys(buildConfigs)
         .sort()
         .map((key) => {
@@ -12404,7 +12566,13 @@ async function generateOptimizedProject(options) {
                 e.products = products[key];
                 throw e;
             })
-                .then((t) => t && (hasTests = true))
+                .then((t) => {
+                if (t.hasTests)
+                    hasTests = true;
+                if (t.diagnostics) {
+                    diagnostics = { ...diagnostics, ...t.diagnostics };
+                }
+            })
             : promises_namespaceObject.rm(external_path_.resolve(workspace, outputPath), {
                 recursive: true,
                 force: true,
@@ -12475,6 +12643,7 @@ async function generateOptimizedProject(options) {
         xml,
         program: external_path_.basename(external_path_.dirname(manifest)),
         hasTests,
+        diagnostics,
     };
 }
 async function fileInfoFromConfig(workspace, output, buildConfig, extraExcludes) {
@@ -12553,7 +12722,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     const actualOptimizedFiles = (await (0,external_util_cjs_namespaceObject.globa)(external_path_.join(output, "**", "*.mc"), { mark: true }))
         .filter((file) => !file.endsWith("/"))
         .sort();
-    const { hasTests, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
+    const { hasTests, diagnostics: prevDiagnostics, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
         .catch(() => "{}"));
     // check that the set of files thats actually there is the same as the
     // set of files we're going to generate (in case eg a jungle file change
@@ -12571,13 +12740,13 @@ 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 && 1654384985724 < opt_time) {
-            return hasTests;
+        if (source_time < opt_time && 1654708837029 < opt_time) {
+            return { hasTests, diagnostics: prevDiagnostics };
         }
     }
     await promises_namespaceObject.rm(output, { recursive: true, force: true });
     await promises_namespaceObject.mkdir(output, { recursive: true });
-    await optimizeMonkeyC(fnMap);
+    const diagnostics = await optimizeMonkeyC(fnMap);
     return Promise.all(Object.values(fnMap).map(async (info) => {
         const name = info.output;
         const dir = external_path_.dirname(name);
@@ -12592,9 +12761,10 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         const hasTests = results.some((v) => v);
         return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
             hasTests,
+            diagnostics,
             ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
         }))
-            .then(() => hasTests);
+            .then(() => ({ hasTests, diagnostics }));
     });
 }
 async function getProjectAnalysis(targets, analysis, options) {