@markw65/monkeyc-optimizer 1.0.13 → 1.0.16

package/build/optimizer.cjs

@@ -1289,7 +1289,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 const debug = __webpack_require__(1227)('extract-zip')
 // eslint-disable-next-line node/no-unsupported-features/node-builtins
 const { createWriteStream, promises: fs } = __webpack_require__(6231)
-const getStream = __webpack_require__(7491)
+const getStream = __webpack_require__(31)
 const path = __webpack_require__(1423)
 const { promisify } = __webpack_require__(6464)
 const stream = __webpack_require__(8311)
@@ -1461,134 +1461,6 @@ module.exports = async function (zipPath, opts) {
 }
 
 
-/***/ }),
-
-/***/ 2297:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const {PassThrough: PassThroughStream} = __webpack_require__(8311);
-
-module.exports = options => {
-	options = {...options};
-
-	const {array} = options;
-	let {encoding} = options;
-	const isBuffer = encoding === 'buffer';
-	let objectMode = false;
-
-	if (array) {
-		objectMode = !(encoding || isBuffer);
-	} else {
-		encoding = encoding || 'utf8';
-	}
-
-	if (isBuffer) {
-		encoding = null;
-	}
-
-	const stream = new PassThroughStream({objectMode});
-
-	if (encoding) {
-		stream.setEncoding(encoding);
-	}
-
-	let length = 0;
-	const chunks = [];
-
-	stream.on('data', chunk => {
-		chunks.push(chunk);
-
-		if (objectMode) {
-			length = chunks.length;
-		} else {
-			length += chunk.length;
-		}
-	});
-
-	stream.getBufferedValue = () => {
-		if (array) {
-			return chunks;
-		}
-
-		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-	};
-
-	stream.getBufferedLength = () => length;
-
-	return stream;
-};
-
-
-/***/ }),
-
-/***/ 7491:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const {constants: BufferConstants} = __webpack_require__(871);
-const pump = __webpack_require__(4286);
-const bufferStream = __webpack_require__(2297);
-
-class MaxBufferError extends Error {
-	constructor() {
-		super('maxBuffer exceeded');
-		this.name = 'MaxBufferError';
-	}
-}
-
-async function getStream(inputStream, options) {
-	if (!inputStream) {
-		return Promise.reject(new Error('Expected a stream'));
-	}
-
-	options = {
-		maxBuffer: Infinity,
-		...options
-	};
-
-	const {maxBuffer} = options;
-
-	let stream;
-	await new Promise((resolve, reject) => {
-		const rejectPromise = error => {
-			// Don't retrieve an oversized buffer.
-			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-				error.bufferedData = stream.getBufferedValue();
-			}
-
-			reject(error);
-		};
-
-		stream = pump(inputStream, bufferStream(options), error => {
-			if (error) {
-				rejectPromise(error);
-				return;
-			}
-
-			resolve();
-		});
-
-		stream.on('data', () => {
-			if (stream.getBufferedLength() > maxBuffer) {
-				rejectPromise(new MaxBufferError());
-			}
-		});
-	});
-
-	return stream.getBufferedValue();
-}
-
-module.exports = getStream;
-// TODO: Remove this for the next major release
-module.exports["default"] = getStream;
-module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
-module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
-module.exports.MaxBufferError = MaxBufferError;
-
-
 /***/ }),
 
 /***/ 8913:
@@ -1892,6 +1764,134 @@ function createFromFd(fd, options) {
 }
 
 
+/***/ }),
+
+/***/ 5105:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {PassThrough: PassThroughStream} = __webpack_require__(8311);
+
+module.exports = options => {
+	options = {...options};
+
+	const {array} = options;
+	let {encoding} = options;
+	const isBuffer = encoding === 'buffer';
+	let objectMode = false;
+
+	if (array) {
+		objectMode = !(encoding || isBuffer);
+	} else {
+		encoding = encoding || 'utf8';
+	}
+
+	if (isBuffer) {
+		encoding = null;
+	}
+
+	const stream = new PassThroughStream({objectMode});
+
+	if (encoding) {
+		stream.setEncoding(encoding);
+	}
+
+	let length = 0;
+	const chunks = [];
+
+	stream.on('data', chunk => {
+		chunks.push(chunk);
+
+		if (objectMode) {
+			length = chunks.length;
+		} else {
+			length += chunk.length;
+		}
+	});
+
+	stream.getBufferedValue = () => {
+		if (array) {
+			return chunks;
+		}
+
+		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
+	};
+
+	stream.getBufferedLength = () => length;
+
+	return stream;
+};
+
+
+/***/ }),
+
+/***/ 31:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {constants: BufferConstants} = __webpack_require__(871);
+const pump = __webpack_require__(4286);
+const bufferStream = __webpack_require__(5105);
+
+class MaxBufferError extends Error {
+	constructor() {
+		super('maxBuffer exceeded');
+		this.name = 'MaxBufferError';
+	}
+}
+
+async function getStream(inputStream, options) {
+	if (!inputStream) {
+		return Promise.reject(new Error('Expected a stream'));
+	}
+
+	options = {
+		maxBuffer: Infinity,
+		...options
+	};
+
+	const {maxBuffer} = options;
+
+	let stream;
+	await new Promise((resolve, reject) => {
+		const rejectPromise = error => {
+			// Don't retrieve an oversized buffer.
+			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+				error.bufferedData = stream.getBufferedValue();
+			}
+
+			reject(error);
+		};
+
+		stream = pump(inputStream, bufferStream(options), error => {
+			if (error) {
+				rejectPromise(error);
+				return;
+			}
+
+			resolve();
+		});
+
+		stream.on('data', () => {
+			if (stream.getBufferedLength() > maxBuffer) {
+				rejectPromise(new MaxBufferError());
+			}
+		});
+	});
+
+	return stream.getBufferedValue();
+}
+
+module.exports = getStream;
+// TODO: Remove this for the next major release
+module.exports["default"] = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
+module.exports.MaxBufferError = MaxBufferError;
+
+
 /***/ }),
 
 /***/ 7824:
@@ -10077,7 +10077,8 @@ async function default_jungle() {
         }
         rezAndLang(deviceId, `resources-${deviceId}`, deviceFamily);
     });
-    return process_assignments(assignments, {});
+    const state = await process_assignments(assignments, {});
+    return { state, devices };
 }
 function process_assignments(assignments, current) {
     return assignments.reduce((state, a) => {
@@ -10179,9 +10180,9 @@ async function process_jungles(sources) {
         sources = [sources];
     }
     const results = await Promise.all(sources.map(parse_one));
-    const state = await default_jungle();
+    const { state, devices } = await default_jungle();
     results.forEach((r) => process_assignments(r, state));
-    return state;
+    return { state, devices };
 }
 function resolve_node_list(state, list) {
     if (!Array.isArray(list)) {
@@ -10303,7 +10304,7 @@ function resolve_filename(literal, default_source = null) {
     const root = external_path_.dirname(literal.source || default_source);
     return external_path_.resolve(root, literal.value);
 }
-async function resolve_literals(qualifier, default_source) {
+async function resolve_literals(qualifier, default_source, deviceInfo) {
     const resolve_file_list = async (literals) => literals &&
         (await Promise.all(literals.map(async (v) => {
             if (!isJNode(v)) {
@@ -10346,7 +10347,13 @@ async function resolve_literals(qualifier, default_source) {
     await resolve_one_file_list(qualifier, "barrelPath");
     const lang = qualifier["lang"];
     if (lang) {
-        await Promise.all(Object.keys(lang).map((key) => resolve_one_file_list(lang, key)));
+        await Promise.all(Object.keys(lang).map((key) => {
+            if (!(0,external_api_cjs_namespaceObject.hasProperty)(deviceInfo.languages, key)) {
+                delete lang[key];
+                return null;
+            }
+            return resolve_one_file_list(lang, key);
+        }));
         if (Object.keys(lang).length === 0)
             delete qualifier["lang"];
     }
@@ -10704,7 +10711,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
             jungles.push(barrels_jungle);
         }
     }
-    const state = await process_jungles(jungles);
+    const { state, devices } = await process_jungles(jungles);
     // apparently square_watch is an alias for rectangle_watch
     state["square_watch"] = state["rectangle_watch"];
     const manifest_node = resolve_node(state, resolve_node_by_path(state, ["project", "manifest"]));
@@ -10719,15 +10726,21 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
     const barrels = manifestBarrels(xml);
     const annotations = manifestAnnotations(xml);
     const products = manifestProducts(xml);
-    if (products.length === 0)
-        products.push(...defaultProducts);
+    if (products.length === 0) {
+        if (defaultProducts) {
+            products.push(...defaultProducts);
+        }
+        else if (xml["iq:manifest"]["iq:barrel"]) {
+            products.push(...Object.keys(devices).sort());
+        }
+    }
     let promise = Promise.resolve();
     const add_one = (product, shape = undefined) => {
         const rawQualifier = resolve_node(state, state[product]);
         if (!rawQualifier || Array.isArray(rawQualifier))
             return;
         promise = promise
-            .then(() => resolve_literals(rawQualifier, manifest))
+            .then(() => resolve_literals(rawQualifier, manifest, devices[product]))
             .then((qualifier) => {
             targets.push({ product, qualifier, shape });
             return resolve_barrels(product, qualifier, barrels, products, options);
@@ -10753,7 +10766,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
 }
 async function get_jungle(jungles, options) {
     options = options || {};
-    const result = await get_jungle_and_barrels(jungles, [], options);
+    const result = await get_jungle_and_barrels(jungles, null, options);
     identify_optimizer_groups(result.targets, options);
     return result;
 }
@@ -10778,11 +10791,282 @@ 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/inliner.ts
+
+function canInline(state, func, args) {
+    // determine whether decl might be changed by a function call
+    // during the evaluation of FunctionStateNode.
+    const getSafety = (decl) => {
+        // enums are constant, they cant change
+        if (decl.type === "EnumStringMember")
+            return true;
+        if (decl.type === "VariableDeclarator") {
+            // constants also can't change
+            if (decl.node.kind === "const")
+                return true;
+            // if decl is a local, it also can't be changed
+            // by a call to another function.
+            for (let i = 0;; i++) {
+                if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                    return false;
+                if (state.stack[i].type === "FunctionDeclaration")
+                    return true;
+            }
+        }
+        return null;
+    };
+    const safeArgs = [];
+    let allSafe = true;
+    if (!args.every((arg) => {
+        switch (arg.type) {
+            case "Literal":
+                safeArgs.push(true);
+                return true;
+            case "Identifier":
+            case "MemberExpression": {
+                const [, results] = state.lookup(arg);
+                if (!results || results.length !== 1)
+                    return false;
+                const safety = getSafety(results[0]);
+                if (safety === null)
+                    return false;
+                if (!safety)
+                    allSafe = false;
+                safeArgs.push(safety);
+                return true;
+            }
+        }
+        return false;
+    })) {
+        return false;
+    }
+    if (allSafe)
+        return true;
+    let callSeen = false;
+    let ok = true;
+    const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
+    const getLoc = (node) => (Array.isArray(node) ? node[0].start : node.start) || 0;
+    // look for uses of "unsafe" args that occur after a call.
+    // use post to do the checking, because arguments are evaluated
+    // prior to the call, so eg "return f(x.y);" is fine, but
+    // "return f()+x.y" is not.
+    //
+    // We also have to use a "pre" to ensure that child nodes are
+    // visited in source order (otherwise we could visit x.y before f()
+    // in the above example)
+    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+        return Object.entries(node)
+            .filter((kv) => Array.isArray(kv[1])
+            ? kv[1].length !== 0 && (0,external_api_cjs_namespaceObject.hasProperty)(kv[1][0], "type")
+            : (0,external_api_cjs_namespaceObject.hasProperty)(kv[1], "type"))
+            .sort(([, a], [, b]) => getLoc(a) - getLoc(b))
+            .map(([key]) => key);
+    }, (node) => {
+        switch (node.type) {
+            case "CallExpression":
+            case "NewExpression":
+                callSeen = true;
+                break;
+            case "Identifier":
+                if (callSeen &&
+                    (0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
+                    !safeArgs[params[node.name]]) {
+                    ok = false;
+                }
+        }
+    });
+    return ok;
+}
+function inliningLooksUseful(func, node) {
+    while (true) {
+        if (node.type === "BinaryExpression" && node.operator === "as") {
+            node = node.left;
+        }
+        else if (node.type === "UnaryExpression" && node.operator === " as") {
+            node = node.argument;
+        }
+        else {
+            break;
+        }
+    }
+    if (node.type === "Literal")
+        return true;
+    if (node.type === "Identifier") {
+        if (func.params.length === 1 &&
+            (0,external_api_cjs_namespaceObject.variableDeclarationName)(func.params[0]) === node.name) {
+            return 1;
+        }
+        return true;
+    }
+    return false;
+}
+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;
+    }
+    const autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
+    const excludeAnnotations = (func.node.loc?.source &&
+        state.fnMap[func.node.loc?.source].excludeAnnotations) ||
+        {};
+    return ((autoInline ||
+        (func.node.attrs &&
+            func.node.attrs.attrs &&
+            func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+                (attr.argument.name === "inline" ||
+                    (attr.argument.name.startsWith("inline_") &&
+                        (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]));
+    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 [];
+                    }
+            }
+            return null;
+        }, (node) => {
+            switch (node.type) {
+                case "Identifier": {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
+                        return call.arguments[params[node.name]];
+                    }
+                    const rep = fixNodeScope(state, node, func.stack);
+                    if (!rep) {
+                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                    }
+                    return rep;
+                }
+            }
+            return null;
+        }) || retArg;
+        result.loc = call.loc;
+        result.start = call.start;
+        result.end = call.end;
+        return result;
+    }
+    catch (ex) {
+        if (ex instanceof Error) {
+            if (ex.message.startsWith("Inliner: ")) {
+                return null;
+            }
+        }
+        throw ex;
+    }
+}
+function applyTypeIfNeeded(node) {
+    if ("enumType" in node && node.enumType) {
+        node = {
+            type: "BinaryExpression",
+            operator: "as",
+            left: node,
+            right: { type: "TypeSpecList", ts: [node.enumType] },
+        };
+    }
+    return node;
+}
+function fixNodeScope(state, lookupNode, nodeStack) {
+    const [, original] = state.lookup(lookupNode, null, nodeStack);
+    if (!original) {
+        return null;
+    }
+    const [, current] = state.lookup(lookupNode);
+    // For now, leave it alone if it already maps to the same thing.
+    // With a bit more work, we could find the guaranteed shortest
+    // reference, and then use this to optimize *all* symbols, not
+    // just fix inlined ones.
+    if (current &&
+        current.length === original.length &&
+        current.every((item, index) => item == original[index])) {
+        return lookupNode;
+    }
+    const node = lookupNode.type === "Identifier"
+        ? lookupNode
+        : lookupNode.property;
+    if (original.length === 1 && original[0].type === "EnumStringMember") {
+        return applyTypeIfNeeded(original[0].init);
+    }
+    const prefixes = original.map((sn) => {
+        if ((0,external_api_cjs_namespaceObject.isStateNode)(sn) && sn.fullName) {
+            return sn.fullName;
+        }
+        return "";
+    });
+    if (prefixes.length &&
+        prefixes[0].startsWith("$.") &&
+        prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
+        const prefix = prefixes[0].split(".").slice(0, -1).reverse();
+        let found = false;
+        return prefix.reduce((current, name) => {
+            if (found)
+                return current;
+            const [, results] = state.lookup(current);
+            if (results &&
+                results.length === original.length &&
+                results.every((result, i) => result === original[i])) {
+                found = true;
+                return current;
+            }
+            const object = typeof name === "string"
+                ? {
+                    type: "Identifier",
+                    name,
+                    start: node.start,
+                    end: node.end,
+                    loc: node.loc,
+                }
+                : name;
+            let root = null;
+            let property = current;
+            while (property.type !== "Identifier") {
+                root = property;
+                property = property.object;
+            }
+            const mb = {
+                type: "MemberExpression",
+                object,
+                property,
+                computed: false,
+                start: node.start,
+                end: node.end,
+                loc: node.loc,
+            };
+            if (root) {
+                root.object = mb;
+            }
+            else {
+                current = mb;
+            }
+            return current;
+        }, node);
+    }
+    return null;
+}
+
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
 
 
+
 function processImports(allImports, lookup) {
     allImports.forEach(({ node, stack }) => {
         const [name, module] = lookup(node.id, ("as" in node && node.as && node.as.name) || null, stack);
@@ -10791,11 +11075,21 @@ function processImports(allImports, lookup) {
             if (!parent.decls)
                 parent.decls = {};
             const decls = parent.decls;
-            if (!(0,external_api_cjs_namespaceObject.hasProperty)(parent.decls, name))
-                parent.decls[name] = [];
+            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 (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] = [];
+                            decls.forEach((decl) => (0,external_util_cjs_namespaceObject.pushUnique)(tdecls[name], decl));
+                        });
+                    }
                 }
             });
         }
@@ -10804,11 +11098,39 @@ function processImports(allImports, lookup) {
 function collectClassInfo(state) {
     state.allClasses.forEach((elm) => {
         if (elm.node.superClass) {
-            const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+            const [name, classes] = state.lookup(elm.node.superClass, null, elm.stack);
             const superClass = classes &&
                 classes.filter((c) => (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) {
+                /*
+                 * The runtime behavior of monkeyc is strange. Lookups
+                 * of the name of the superclass, either bare, or via self.<name>
+                 * always find the superclass, even if there's a member variable
+                 * or method of the same name. So its ok to just overwrite
+                 * elm.decls[name] here.
+                 *
+                 * ie
+                 *
+                 * class A { function foo() as Number { return 1; } }
+                 * class B { function foo() as String { return "B"; } }
+                 * class C extends A {
+                 *   var A as B = new B();
+                 *   function initialize() {
+                 *     A.initialize(); // class A's initialize
+                 *     A.foo(); // returns 1
+                 *     self.A.foo(); // still returns 1
+                 *   }
+                 * }
+                 *
+                 * The typechecker seems to get confused in some circumstances
+                 * though (ie it doesn't always use the same rules)
+                 */
+                if (!elm.decls)
+                    elm.decls = {};
+                elm.decls[name] = elm.superClass;
+            }
         }
     });
     const markOverrides = (cls, scls) => {
@@ -10863,32 +11185,36 @@ function getFileASTs(fnMap) {
     }, true));
 }
 async function analyze(fnMap) {
-    let excludeAnnotations;
     let hasTests = false;
     const allImports = [];
     const preState = {
+        fnMap,
         allFunctions: [],
         allClasses: [],
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
                 "attrs" in node.attrs &&
-                node.attrs.attrs) {
-                return node.attrs.attrs.reduce((drop, attr) => {
-                    if (attr.type != "UnaryExpression")
-                        return drop;
-                    if (attr.argument.type != "Identifier")
+                node.attrs.attrs &&
+                node.loc?.source) {
+                const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
+                if (excludeAnnotations) {
+                    return node.attrs.attrs.reduce((drop, attr) => {
+                        if (attr.type != "UnaryExpression")
+                            return drop;
+                        if (attr.argument.type != "Identifier")
+                            return drop;
+                        if ((0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name)) {
+                            return true;
+                        }
+                        if (attr.argument.name == "test") {
+                            hasTests = true;
+                        }
                         return drop;
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name)) {
-                        return true;
-                    }
-                    if (attr.argument.name == "test") {
-                        hasTests = true;
-                    }
-                    return drop;
-                }, false);
+                    }, false);
+                }
             }
-            return null;
+            return false;
         },
         post(node, state) {
             switch (node.type) {
@@ -10935,7 +11261,6 @@ async function analyze(fnMap) {
         if (!ast) {
             throw parserError || new Error(`Failed to parse ${name}`);
         }
-        excludeAnnotations = value.excludeAnnotations;
         hasTests = false;
         (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
         value.hasTests = hasTests;
@@ -10959,8 +11284,8 @@ function getLiteralFromDecls(decls) {
     let result = null;
     if (decls.every((d) => {
         if (d.type === "EnumStringMember" ||
-            (d.type === "VariableDeclarator" && d.kind === "const")) {
-            const init = getLiteralNode(d.init);
+            (d.type === "VariableDeclarator" && d.node.kind === "const")) {
+            const init = getLiteralNode(d.type === "EnumStringMember" ? d.init : d.node.init);
             if (!init)
                 return false;
             if (!result) {
@@ -11242,11 +11567,12 @@ async function optimizeMonkeyC(fnMap) {
      * anywhere in its superClass chain.
      */
     const checkInherited = (elm, name) => elm.superClass === true ||
-        elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
-            sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
-                f.type == "FunctionDeclaration" &&
-                maybeCalled(f.node))) ||
-            (sc.superClass && checkInherited(sc, name)));
+        (elm.superClass != null &&
+            elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
+                sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
+                    f.type == "FunctionDeclaration" &&
+                    maybeCalled(f.node))) ||
+                (sc.superClass && checkInherited(sc, name))));
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
@@ -11489,11 +11815,9 @@ async function optimizeMonkeyC(fnMap) {
                     }
                     return null;
                 }
-                if (callees.length == 1) {
-                    const callee = (0,external_api_cjs_namespaceObject.isStateNode)(callees[0]) && callees[0].node;
-                    if (callee &&
-                        callee.type == "FunctionDeclaration" &&
-                        callee.optimizable &&
+                if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
+                    const callee = callees[0].node;
+                    if (callee.optimizable &&
                         !callee.hasOverride &&
                         node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
                         const ret = evaluateFunction(callee, node.arguments);
@@ -11502,6 +11826,13 @@ async function optimizeMonkeyC(fnMap) {
                             return null;
                         }
                     }
+                    if (shouldInline(state, callees[0], node.arguments)) {
+                        const ret = inlineFunction(state, callees[0], node);
+                        if (ret) {
+                            replace(node, ret);
+                            return null;
+                        }
+                    }
                 }
                 if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
                     state.calledFunctions[name] = [];
@@ -11515,71 +11846,79 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
-    Object.values(fnMap).forEach((f) => {
-        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
-            switch (node.type) {
-                case "EnumStringBody":
-                    if (node.members.every((m) => {
-                        const name = "name" in m ? m.name : m.id.name;
-                        return ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
-                            !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
-                    })) {
-                        node.enumType = [
-                            ...new Set(node.members.map((m) => {
-                                if (!("init" in m))
-                                    return "Number";
-                                const [node, type] = getNodeValue(m.init);
-                                if (!node) {
-                                    throw new Error("Failed to get type for eliminated enum");
-                                }
-                                return type;
-                            })),
-                        ].join(" or ");
-                        node.members.splice(0);
-                    }
-                    break;
-                case "EnumDeclaration":
-                    if (!node.body.members.length) {
-                        if (!node.id)
-                            return false;
-                        if (!node.body["enumType"]) {
-                            throw new Error("Missing enumType on optimized enum");
-                        }
-                        replace(node, {
-                            type: "TypedefDeclaration",
-                            id: node.id,
-                            ts: {
-                                type: "UnaryExpression",
-                                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
-                                prefix: true,
-                                operator: " as",
-                            },
-                        });
-                    }
-                    break;
-                case "VariableDeclaration": {
-                    node.declarations = node.declarations.filter((d) => {
-                        const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(d.id);
-                        return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) ||
-                            (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
-                    });
-                    if (!node.declarations.length) {
-                        return false;
-                    }
-                    break;
+    delete state.pre;
+    delete state.post;
+    const cleanup = (node) => {
+        switch (node.type) {
+            case "EnumStringBody":
+                if (node.members.every((m) => {
+                    const name = "name" in m ? m.name : m.id.name;
+                    return ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
+                        !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
+                })) {
+                    node.enumType = [
+                        ...new Set(node.members.map((m) => {
+                            if (!("init" in m))
+                                return "Number";
+                            const [node, type] = getNodeValue(m.init);
+                            if (!node) {
+                                throw new Error("Failed to get type for eliminated enum");
+                            }
+                            return type;
+                        })),
+                    ].join(" or ");
+                    node.members.splice(0);
                 }
-                case "ClassElement":
-                    if (!node.item) {
-                        return false;
-                    }
-                    break;
-                case "FunctionDeclaration":
-                    if (!maybeCalled(node)) {
+                break;
+            case "EnumDeclaration":
+                if (!node.body.members.length) {
+                    if (!node.id)
                         return false;
+                    if (!node.body["enumType"]) {
+                        throw new Error("Missing enumType on optimized enum");
                     }
-                    break;
+                    replace(node, {
+                        type: "TypedefDeclaration",
+                        id: node.id,
+                        ts: {
+                            type: "UnaryExpression",
+                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            prefix: true,
+                            operator: " as",
+                        },
+                    });
+                }
+                break;
+            case "VariableDeclaration": {
+                node.declarations = node.declarations.filter((d) => {
+                    const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(d.id);
+                    return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) || (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
+                });
+                if (!node.declarations.length) {
+                    return false;
+                }
+                break;
             }
-            return null;
+            case "ClassElement":
+                if (!node.item) {
+                    return false;
+                }
+                break;
+            case "FunctionDeclaration":
+                if (!maybeCalled(node)) {
+                    return false;
+                }
+                break;
+        }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
+            const ret = cleanup(node);
+            if (ret === false) {
+                state.removeNodeComments(node, f.ast);
+            }
+            return ret;
         });
     });
 }
@@ -11996,6 +12335,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     // might have altered it), and that the options we care about haven't
     // changed
     if (hasTests != null &&
+        !config.checkBuildPragmas &&
         configOptionsToCheck.every((option) => prevOptions[option] === config[option]) &&
         actualOptimizedFiles.length == Object.values(fnMap).length &&
         Object.values(fnMap)
@@ -12006,7 +12346,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 && 1653671578547 < opt_time) {
+        if (source_time < opt_time && 1654222986123 < opt_time) {
             return hasTests;
         }
     }
@@ -12018,6 +12358,14 @@ 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);
+        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}'`);
+                }
+            }
+        }
         await promises_namespaceObject.writeFile(name, opt_source);
         return info.hasTests;
     })).then((results) => {
@@ -12075,11 +12423,12 @@ async function generateApiMirTests(options) {
                     return;
                 const d = decl[0];
                 if (d.type === "EnumStringMember" ||
-                    (d.type === "VariableDeclarator" && d.kind === "const")) {
-                    if (!d.init) {
+                    (d.type === "VariableDeclarator" && d.node.kind === "const")) {
+                    const init = (0,external_api_cjs_namespaceObject.isStateNode)(d) ? d.node.init : d.init;
+                    if (!init) {
                         throw new Error(`Missing init for ${node.fullName}.${key}`);
                     }
-                    tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(d.init)]);
+                    tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(init)]);
                 }
                 else if ((0,external_api_cjs_namespaceObject.isStateNode)(d)) {
                     findConstants(d);