@markw65/monkeyc-optimizer 1.0.16 → 1.0.17

package/build/optimizer.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,get_jungle,launchSimulator,manifestProducts,mctree,simulateProgram,defaultConfig,isErrorWithLocation,buildOptimizedProject,generateOptimizedProject,getProjectAnalysis,generateApiMirTests});
+0 && (module.exports = {buildOptimizedProject,copyRecursiveAsNeeded,defaultConfig,generateApiMirTests,generateOptimizedProject,getProjectAnalysis,get_jungle,isErrorWithLocation,launchSimulator,manifestProducts,mctree,simulateProgram});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -10791,11 +10791,67 @@ function simulateProgram(prg, device, test) {
     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(() => { }));
 }
 
+;// CONCATENATED MODULE: ./src/variable-renamer.ts
+
+function renameVariable(state, locals, declName) {
+    const map = locals.map;
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, declName))
+        return null;
+    let suffix = 0;
+    let node_name = declName;
+    const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
+    if (match) {
+        node_name = match[1];
+        suffix = parseInt(match[2], 10) + 1;
+    }
+    if (!locals.inners) {
+        // find all the names declared in this scope, to avoid
+        // more conflicts
+        locals.inners = {};
+        const inners = locals.inners;
+        (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
+            if (node.type === "VariableDeclarator") {
+                inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
+            }
+        });
+    }
+    let name;
+    while (true) {
+        name = `pmcr_${node_name}_${suffix}`;
+        if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, name) && !(0,external_api_cjs_namespaceObject.hasProperty)(locals.inners, name)) {
+            // we also need to ensure that we don't hide the name of
+            // an outer module, class, function, enum or variable,
+            // since someone might want to access it from this scope.
+            let ok = false;
+            let i;
+            for (i = state.stack.length; i--;) {
+                const elm = state.stack[i];
+                if (ok) {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(elm.decls, name)) {
+                        break;
+                    }
+                }
+                else if (elm.node && elm.node.type === "FunctionDeclaration") {
+                    ok = true;
+                }
+            }
+            if (i < 0) {
+                break;
+            }
+        }
+        suffix++;
+    }
+    map[declName] = name;
+    map[name] = true;
+    return name;
+}
+
 ;// CONCATENATED MODULE: ./src/inliner.ts
 
-function canInline(state, func, args) {
+
+function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
-    // during the evaluation of FunctionStateNode.
+    // or assignment during the evaluation of FunctionStateNode.
     const getSafety = (decl) => {
         // enums are constant, they cant change
         if (decl.type === "EnumStringMember")
@@ -10825,18 +10881,24 @@ function canInline(state, func, args) {
             case "Identifier":
             case "MemberExpression": {
                 const [, results] = state.lookup(arg);
-                if (!results || results.length !== 1)
-                    return false;
+                if (!results || results.length !== 1) {
+                    safeArgs.push(null);
+                    return !requireAll;
+                }
                 const safety = getSafety(results[0]);
-                if (safety === null)
-                    return false;
-                if (!safety)
-                    allSafe = false;
                 safeArgs.push(safety);
+                if (!safety) {
+                    allSafe = false;
+                    if (safety === null) {
+                        return !requireAll;
+                    }
+                }
                 return true;
             }
         }
-        return false;
+        allSafe = false;
+        safeArgs.push(null);
+        return !requireAll;
     })) {
         return false;
     }
@@ -10865,17 +10927,26 @@ function canInline(state, func, args) {
         switch (node.type) {
             case "CallExpression":
             case "NewExpression":
+            case "AssignmentExpression":
+            case "UpdateExpression":
                 callSeen = true;
                 break;
             case "Identifier":
                 if (callSeen &&
                     (0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
                     !safeArgs[params[node.name]]) {
-                    ok = false;
+                    safeArgs[params[node.name]] = null;
                 }
         }
     });
-    return ok;
+    return safeArgs;
+}
+function canInline(state, func, args) {
+    const safeArgs = getArgSafety(state, func, args, true);
+    if (safeArgs === true || safeArgs === false) {
+        return safeArgs;
+    }
+    return safeArgs.every((arg) => arg !== null);
 }
 function inliningLooksUseful(func, node) {
     while (true) {
@@ -10900,68 +10971,114 @@ 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 shouldInline(state, func, args) {
-    if (!func.node.body ||
-        func.node.body.body.length !== 1 ||
-        func.node.body.body[0].type !== "ReturnStatement" ||
-        !func.node.body.body[0].argument ||
-        func.node.params.length !== args.length) {
-        return false;
+    let autoInline = false;
+    let inlineAsExpression = false;
+    if (func.node.body &&
+        func.node.body.body.length === 1 &&
+        func.node.body.body[0].type === "ReturnStatement" &&
+        func.node.body.body[0].argument &&
+        func.node.params.length === args.length) {
+        inlineAsExpression = true;
+        autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
+    }
+    if (autoInline === 1) {
+        return InlineStatus.AsExpression;
     }
-    const autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
     const excludeAnnotations = (func.node.loc?.source &&
-        state.fnMap[func.node.loc?.source].excludeAnnotations) ||
+        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
         {};
-    return ((autoInline ||
-        (func.node.attrs &&
-            func.node.attrs.attrs &&
-            func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
-                (attr.argument.name === "inline" ||
-                    (attr.argument.name.startsWith("inline_") &&
-                        (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7))))))) &&
-        (autoInline === 1 || canInline(state, func, args)));
-}
-function inlineFunction(state, func, call) {
-    const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
-    const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
+    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;
+    }
+    return InlineStatus.Never;
+}
+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];
+        }));
+    }
+    const pre = state.pre;
+    const post = state.post;
     try {
-        const result = (0,external_api_cjs_namespaceObject.traverseAst)(retArg, (node) => {
-            switch (node.type) {
-                case "MemberExpression":
-                    if (!node.computed) {
-                        return ["object"];
-                    }
-                    break;
-                case "BinaryExpression":
-                    if (node.operator === "as") {
-                        return ["left"];
-                    }
-                    break;
-                case "UnaryExpression":
-                    if (node.operator === " as") {
-                        return [];
-                    }
+        state.pre = (node) => {
+            node.start = call.start;
+            node.end = call.end;
+            node.loc = call.loc;
+            if (node === insertedVariableDecls)
+                return false;
+            const result = pre(node, state);
+            if (!insertedVariableDecls && node.type === "BlockStatement") {
+                const locals = state.localsStack[state.localsStack.length - 1];
+                const { map } = locals;
+                if (!map)
+                    throw new Error("No local variable map!");
+                const declarations = func.node.params
+                    .map((param, i) => {
+                    const paramName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
+                    if (params[paramName] >= 0)
+                        return null;
+                    const name = renameVariable(state, locals, paramName) || paramName;
+                    return {
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name },
+                        kind: "var",
+                        init: call.arguments[i],
+                    };
+                })
+                    .filter((n) => n != null);
+                insertedVariableDecls = {
+                    type: "VariableDeclaration",
+                    declarations,
+                    kind: "var",
+                };
+                node.body.unshift(insertedVariableDecls);
             }
-            return null;
-        }, (node) => {
+            return result;
+        };
+        state.post = (node) => {
+            let replacement = null;
             switch (node.type) {
                 case "Identifier": {
+                    if (state.inType)
+                        break;
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
-                        return call.arguments[params[node.name]];
+                        const ix = params[node.name];
+                        if (ix >= 0) {
+                            replacement = call.arguments[ix];
+                        }
+                        break;
                     }
-                    const rep = fixNodeScope(state, node, func.stack);
-                    if (!rep) {
+                    replacement = fixNodeScope(state, node, func.stack);
+                    if (!replacement) {
                         throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
                     }
-                    return rep;
+                    break;
                 }
             }
-            return null;
-        }) || retArg;
-        result.loc = call.loc;
-        result.start = call.start;
-        result.end = call.end;
-        return result;
+            return post(replacement || node, state) || replacement;
+        };
+        return state.traverse(root) || null;
     }
     catch (ex) {
         if (ex instanceof Error) {
@@ -10971,6 +11088,75 @@ function inlineFunction(state, func, call) {
         }
         throw ex;
     }
+    finally {
+        state.pre = pre;
+        state.post = post;
+    }
+}
+function unused(expression, top) {
+    switch (expression.type) {
+        case "Literal":
+            return [];
+        case "Identifier":
+            return [];
+        case "BinaryExpression":
+            if (expression.operator === "as") {
+                return unused(expression.left);
+            }
+        // fall through
+        case "LogicalExpression":
+            return unused(expression.left).concat(unused(expression.right));
+        case "UnaryExpression":
+            return unused(expression.argument);
+        case "MemberExpression":
+            return unused(expression.object).concat(unused(expression.property));
+    }
+    return top
+        ? null
+        : [
+            {
+                type: "ExpressionStatement",
+                expression,
+            },
+        ];
+}
+function inlineWithArgs(state, func, call) {
+    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;
+    }
+    const body = JSON.parse(JSON.stringify(func.node.body));
+    processInlineBody(state, func, call, body, func.node.params.length ? false : true);
+    if (retStmtCount) {
+        const last = body.body[body.body.length - 1];
+        if (last.type != "ReturnStatement") {
+            throw new Error("ReturnStatement got lost!");
+        }
+        if (last.argument) {
+            const side_exprs = unused(last.argument);
+            body.body.splice(body.body.length - 1, 1, ...side_exprs);
+        }
+        else {
+            --body.body.length;
+        }
+    }
+    return body;
+}
+function inlineFunction(state, func, call, inlineStatus) {
+    if (inlineStatus == InlineStatus.AsStatement) {
+        return inlineWithArgs(state, func, call);
+    }
+    const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
+    const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
+    return processInlineBody(state, func, call, retArg, true, params) || retArg;
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -10984,6 +11170,16 @@ function applyTypeIfNeeded(node) {
     return 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 [, original] = state.lookup(lookupNode, null, nodeStack);
     if (!original) {
         return null;
@@ -11067,6 +11263,7 @@ 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);
@@ -11080,10 +11277,13 @@ function processImports(allImports, lookup) {
             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) {
-                        if (!parent.type_decls)
-                            parent.type_decls = {};
-                        const tdecls = parent.type_decls;
                         Object.entries(m.type_decls).forEach(([name, decls]) => {
                             if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
                                 tdecls[name] = [];
@@ -11624,57 +11824,8 @@ async function optimizeMonkeyC(fnMap) {
                 const { map } = locals;
                 if (map) {
                     const declName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id);
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(map, declName)) {
-                        // We already have a variable with this name in scope
-                        // Recent monkeyc compilers complain, so rename it
-                        let suffix = 0;
-                        let node_name = declName;
-                        const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
-                        if (match) {
-                            node_name = match[1];
-                            suffix = parseInt(match[2], 10) + 1;
-                        }
-                        if (!locals.inners) {
-                            // find all the names declared in this scope, to avoid
-                            // more conflicts
-                            locals.inners = {};
-                            const inners = locals.inners;
-                            (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
-                                if (node.type === "VariableDeclarator") {
-                                    inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
-                                }
-                            });
-                        }
-                        let name;
-                        while (true) {
-                            name = `pmcr_${node_name}_${suffix}`;
-                            if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, name) &&
-                                !(0,external_api_cjs_namespaceObject.hasProperty)(locals.inners, name)) {
-                                // we also need to ensure that we don't hide the name of
-                                // an outer module, class, function, enum or variable,
-                                // since someone might want to access it from this scope.
-                                let ok = false;
-                                let i;
-                                for (i = state.stack.length; i--;) {
-                                    const elm = state.stack[i];
-                                    if (ok) {
-                                        if ((0,external_api_cjs_namespaceObject.hasProperty)(elm.decls, name)) {
-                                            break;
-                                        }
-                                    }
-                                    else if (elm.node &&
-                                        elm.node.type === "FunctionDeclaration") {
-                                        ok = true;
-                                    }
-                                }
-                                if (i < 0) {
-                                    break;
-                                }
-                            }
-                            suffix++;
-                        }
-                        map[declName] = name;
-                        map[name] = true;
+                    const name = renameVariable(state, locals, declName);
+                    if (name) {
                         if (node.id.type === "Identifier") {
                             node.id.name = name;
                         }
@@ -11698,7 +11849,7 @@ async function optimizeMonkeyC(fnMap) {
                     state.exposed[node.argument.name] = true;
                     // In any case, we can't replace *this* use of the
                     // symbol with its value...
-                    return false;
+                    return [];
                 }
                 break;
             case "Identifier": {
@@ -11716,7 +11867,7 @@ async function optimizeMonkeyC(fnMap) {
                         state.exposed[node.name] = true;
                     }
                 }
-                return false;
+                return [];
             }
             case "MemberExpression":
                 if (node.property.type === "Identifier" && !node.computed) {
@@ -11798,48 +11949,29 @@ async function optimizeMonkeyC(fnMap) {
                 }
                 break;
             case "CallExpression": {
-                const [name, callees] = state.lookup(node.callee);
-                if (!callees || !callees.length) {
-                    const n = name ||
-                        ("name" in node.callee && node.callee.name) ||
-                        ("property" in node.callee &&
-                            node.callee.property &&
-                            "name" in node.callee.property &&
-                            node.callee.property.name);
-                    if (n) {
-                        state.exposed[n] = true;
-                    }
-                    else {
-                        // There are unnamed CallExpressions, such as new [size]
-                        // So there's nothing to do here.
-                    }
-                    return null;
+                const ret = optimizeCall(state, node, false);
+                if (ret) {
+                    replace(node, ret);
                 }
-                if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
-                    const callee = callees[0].node;
-                    if (callee.optimizable &&
-                        !callee.hasOverride &&
-                        node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
-                        const ret = evaluateFunction(callee, node.arguments);
-                        if (ret) {
-                            replace(node, ret);
-                            return null;
-                        }
-                    }
-                    if (shouldInline(state, callees[0], node.arguments)) {
-                        const ret = inlineFunction(state, callees[0], node);
-                        if (ret) {
-                            replace(node, ret);
-                            return null;
+                break;
+            }
+            case "ExpressionStatement":
+                if (node.expression.type === "CallExpression") {
+                    const ret = optimizeCall(state, node.expression, true);
+                    if (ret) {
+                        if (ret.type === "BlockStatement") {
+                            return ret;
                         }
+                        node.expression = ret;
                     }
                 }
-                if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
-                    state.calledFunctions[name] = [];
+                else {
+                    const ret = unused(node.expression, true);
+                    if (ret) {
+                        return ret;
+                    }
                 }
-                callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && state.calledFunctions[name].push(c.node));
                 break;
-            }
         }
         return null;
     };
@@ -11922,6 +12054,98 @@ async function optimizeMonkeyC(fnMap) {
         });
     });
 }
+function optimizeCall(state, node, asStatement) {
+    const [name, callees] = state.lookup(node.callee);
+    if (!callees || !callees.length) {
+        const n = name ||
+            ("name" in node.callee && node.callee.name) ||
+            ("property" in node.callee &&
+                node.callee.property &&
+                "name" in node.callee.property &&
+                node.callee.property.name);
+        if (n) {
+            state.exposed[n] = true;
+        }
+        else {
+            // There are unnamed CallExpressions, such as new [size]
+            // So there's nothing to do here.
+        }
+        return null;
+    }
+    if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
+        const callee = callees[0].node;
+        if (callee.optimizable &&
+            !callee.hasOverride &&
+            node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
+            const ret = evaluateFunction(callee, node.arguments);
+            if (ret) {
+                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 (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));
+    return null;
+}
+
+;// CONCATENATED MODULE: ./src/pragma-checker.ts
+
+function pragmaChecker(ast) {
+    const comments = ast.comments;
+    if (!comments)
+        return;
+    let index = -1;
+    let comment;
+    const next = () => {
+        while (++index < comments.length) {
+            comment = comments[index];
+            if (comment.value.match(/^\s*@match\s+/)) {
+                break;
+            }
+        }
+    };
+    next();
+    (0,external_api_cjs_namespaceObject.traverseAst)(ast, (node) => {
+        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 haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/[\r\n]/g, " ");
+            let found = false;
+            let needle = match[1];
+            if (match.length == 2) {
+                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);
+                }
+            }
+            if (!found) {
+                throw new Error(`Didn't find '${needle}' in ${comment.loc.source}:${comment.loc.start.line}`);
+            }
+            next();
+        }
+        return null;
+    });
+}
 
 ;// CONCATENATED MODULE: ./src/optimizer.ts
 
@@ -11937,6 +12161,7 @@ async function optimizeMonkeyC(fnMap) {
 
 
 
+
 function relative_path_no_dotdot(relative) {
     return relative.replace(/^(\.\.[\\\/])+/, (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`);
 }
@@ -12346,7 +12571,7 @@ 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 && 1654222986123 < opt_time) {
+        if (source_time < opt_time && 1654384985724 < opt_time) {
             return hasTests;
         }
     }
@@ -12358,15 +12583,10 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         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) {
-            const matches = opt_source.matchAll(/^.*\/\*\s*@match\s+(\S+)\s+\*\/(.*)$/gm);
-            for (const [line, needle, haystack] of matches) {
-                if (!haystack.includes(needle)) {
-                    throw new Error(`Checking build pragmas in ${name} failed at \n\n${line}\n\n - Didn't find '${needle}'`);
-                }
-            }
+            pragmaChecker(info.ast);
         }
-        await promises_namespaceObject.writeFile(name, opt_source);
         return info.hasTests;
     })).then((results) => {
         const hasTests = results.some((v) => v);