@markw65/monkeyc-optimizer 1.0.30 → 1.0.33

package/build/optimizer.cjs

@@ -10977,6 +10977,7 @@ function simulateProgram(prg, device, test = false, logger) {
 }
 
 ;// CONCATENATED MODULE: ./src/ast.ts
+
 /*
  * This ensures that mctreeTypeInfo has every key of MCTreeTypeInfo,
  * and that the corresponding arrays contain every element of the
@@ -11163,18 +11164,185 @@ function withLoc(node, start, end) {
     }
     return node;
 }
-function withLocDeep(node, start, end) {
-    node = withLoc({ ...node }, start, end);
+function withLocDeep(node, start, end, inplace) {
+    node = withLoc(inplace ? node : { ...node }, start, end);
     for (const key of mctreeTypeInfo[node.type].keys) {
         const value = node[key];
         if (!value)
             continue;
-        const fix = (v) => isMCTreeNode(v) ? withLocDeep(v, start, end) : v;
+        const fix = (v) => isMCTreeNode(v) ? withLocDeep(v, start, end, inplace) : v;
         const repl = Array.isArray(value) ? value.map(fix) : fix(value);
-        node[key] = repl;
+        inplace || (node[key] = repl);
     }
     return node;
 }
+function cloneDeep(node) {
+    return withLocDeep(node, null);
+}
+function getNodeValue(node) {
+    if (node.type == "BinaryExpression" &&
+        node.operator == "as" &&
+        node.right.type == "TypeSpecList" &&
+        node.right.ts.length == 1 &&
+        typeof node.right.ts[0] == "string") {
+        // this is a cast we inserted to retain the type of an enum
+        // any arithmetic on it will revert to "Number", or "Long",
+        // so just ignore it.
+        return getNodeValue(node.left);
+    }
+    if (node.type != "Literal") {
+        return [null, null];
+    }
+    if (node.value === null) {
+        return [node, "Null"];
+    }
+    const type = typeof node.value;
+    if (type === "number") {
+        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
+        if (match) {
+            return match[2] === "l" || match[2] === "L"
+                ? [node, "Long"]
+                : [node, "Number"];
+        }
+        return [node, node.raw.endsWith("d") ? "Double" : "Float"];
+    }
+    if (type === "bigint") {
+        return [node, "Long"];
+    }
+    if (type === "string") {
+        return [node, "String"];
+    }
+    if (type === "boolean") {
+        return [node, "Boolean"];
+    }
+    throw new Error(`Literal has unknown type '${type}'`);
+}
+
+;// CONCATENATED MODULE: ./src/function-info.ts
+
+function cloneSet(ae) {
+    return new Set(ae);
+}
+function mergeSet(a, b) {
+    b.forEach((event) => a.add(event));
+}
+function recordModifiedDecl(func, decl) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    func.next_info.modifiedDecls.add(decl);
+    return null;
+}
+function recordModifiedDecls(func, lookupDefs) {
+    lookupDefs.forEach((lookupDef) => lookupDef.results.forEach((result) => {
+        if (result.type == "VariableDeclarator" && result.node.kind === "var") {
+            recordModifiedDecl(func, result);
+        }
+    }));
+}
+function recordModifiedName(func, name) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    if (!func.next_info.modifiedNames) {
+        func.next_info.modifiedNames = new Set();
+    }
+    func.next_info.modifiedNames.add(name);
+}
+function recordModifiedUnknown(func) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    func.next_info.modifiedUnknown = true;
+}
+function recordCalledFunc(func, callee) {
+    if (!func.next_info) {
+        func.next_info = { modifiedDecls: new Set(), calledFuncs: new Set() };
+    }
+    func.next_info.calledFuncs.add(callee);
+    return null;
+}
+function recordCalledFuncs(func, callees) {
+    callees.forEach((callee) => {
+        recordCalledFunc(func, callee);
+    });
+}
+function functionMayModify(state, func, decl) {
+    const info = func.info;
+    if (!info || info.modifiedUnknown)
+        return true;
+    if (info.resolvedDecls) {
+        return info.resolvedDecls.has(decl);
+    }
+    if (info.modifiedNames?.has(decl.name))
+        return true;
+    if (info.modifiedDecls.has(decl))
+        return true;
+    const visited = new Set();
+    const resolved = new Set();
+    const resolveDecls = (f) => {
+        if (visited.has(f))
+            return true;
+        if (!f.info)
+            return false;
+        if (f.info.modifiedUnknown) {
+            info.modifiedUnknown = true;
+            return false;
+        }
+        if (f.info.modifiedNames) {
+            if (info.modifiedNames) {
+                mergeSet(info.modifiedNames, f.info.modifiedNames);
+            }
+            else {
+                info.modifiedNames = cloneSet(f.info.modifiedNames);
+            }
+        }
+        mergeSet(resolved, f.info.modifiedDecls);
+        visited.add(f);
+        const q = true;
+        if (q &&
+            f.info.callsExposed &&
+            state.exposed &&
+            !Object.keys(state.exposed).every((key) => !state.allFunctions[key] ||
+                state.allFunctions[key].every(resolveDecls))) {
+            return false;
+        }
+        return Array.from(f.info.calledFuncs).every(resolveDecls);
+    };
+    if (resolveDecls(func)) {
+        info.resolvedDecls = resolved;
+        return resolved.has(decl);
+    }
+    return true;
+}
+function findCallees(lookupDefs) {
+    const decls = lookupDefs.reduce((decls, r) => (decls ? decls.concat(r.results) : r.results), null);
+    return (decls &&
+        decls.filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
+}
+function findCalleesForNew(lookupDefs) {
+    const initializer = (decl) => {
+        if (hasProperty(decl.decls, "initialize")) {
+            return decl.decls["initialize"];
+        }
+        if (decl.superClass && decl.superClass !== true) {
+            return decl.superClass.reduce((cur, cls) => {
+                const init = initializer(cls);
+                if (init) {
+                    if (!cur)
+                        return init;
+                    return cur.concat(init);
+                }
+                return cur;
+            }, null);
+        }
+        return null;
+    };
+    return lookupDefs.flatMap((r) => r.results
+        .filter((decl) => decl.type === "ClassDeclaration")
+        .flatMap(initializer)
+        .filter((decl) => decl ? decl.type === "FunctionDeclaration" : false));
+}
 
 ;// CONCATENATED MODULE: ./src/variable-renamer.ts
 
@@ -11236,6 +11404,7 @@ function renameVariable(state, locals, declName) {
 
 
 
+
 function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
@@ -11268,8 +11437,9 @@ function getArgSafety(state, func, args, requireAll) {
         }
     };
     const safeArgs = [];
+    const argDecls = [];
     let allSafe = true;
-    if (!args.every((arg) => {
+    if (!args.every((arg, i) => {
         switch (arg.type) {
             case "Literal":
                 safeArgs.push(true);
@@ -11283,13 +11453,17 @@ function getArgSafety(state, func, args, requireAll) {
                     safeArgs.push(null);
                     return !requireAll;
                 }
-                const safety = getSafety(results[0].results[0]);
+                const decl = results[0].results[0];
+                const safety = getSafety(decl);
                 safeArgs.push(safety);
                 if (!safety) {
                     allSafe = false;
                     if (safety === null) {
                         return !requireAll;
                     }
+                    else if (decl.type === "VariableDeclarator") {
+                        argDecls[i] = decl;
+                    }
                 }
                 return true;
             }
@@ -11302,34 +11476,91 @@ function getArgSafety(state, func, args, requireAll) {
     }
     if (allSafe && requireAll)
         return true;
-    let callSeen = false;
+    const callsSeen = new Set();
+    const modifiedDecls = new Set();
+    let modifiedUnknown = false;
     const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
     // 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.
-    traverseAst(func.node.body, null, (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;
+    const { pre, post, stack } = state;
+    try {
+        delete state.pre;
+        state.post = (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)) {
+                        // If a parameter is modified, we can't just substitute the
+                        // argument wherever the parameter is used.
+                        safeArgs[params[v.name]] = null;
+                        break;
+                    }
+                    if (modifiedUnknown)
+                        break;
+                    const [, results] = state.lookup(v);
+                    if (results) {
+                        results.forEach((r) => r.results.forEach((decl) => decl.type === "VariableDeclarator" && modifiedDecls.add(decl)));
+                    }
+                    else {
+                        modifiedUnknown = true;
+                    }
+                    break;
                 }
+                case "CallExpression":
+                case "NewExpression":
+                    if (!modifiedUnknown) {
+                        const [, results] = state.lookup(node.callee, null, 
+                        // calls are looked up as non-locals, but new is not
+                        node.type === "CallExpression" ? func.stack : state.stack);
+                        if (!results) {
+                            const callee_name = node.callee.type === "Identifier"
+                                ? node.callee
+                                : node.callee.type === "MemberExpression"
+                                    ? (0,external_api_cjs_namespaceObject.isLookupCandidate)(node.callee)
+                                    : null;
+                            if (callee_name) {
+                                const callees = state.allFunctions[callee_name.name];
+                                if (callees) {
+                                    callees.forEach((callee) => callsSeen.add(callee));
+                                }
+                            }
+                            else {
+                                modifiedUnknown = true;
+                            }
+                        }
+                        else {
+                            const callees = node.type === "CallExpression"
+                                ? findCallees(results)
+                                : findCalleesForNew(results);
+                            if (callees) {
+                                callees.forEach((callee) => callsSeen.add(callee));
+                            }
+                        }
+                    }
+                    break;
+                case "Identifier":
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
+                        !safeArgs[params[node.name]] &&
+                        (modifiedUnknown ||
+                            !argDecls[params[node.name]] ||
+                            modifiedDecls.has(argDecls[params[node.name]]) ||
+                            Array.from(callsSeen).some((callee) => functionMayModify(state, callee, argDecls[params[node.name]])))) {
+                        safeArgs[params[node.name]] = null;
+                    }
             }
-            // fall through
-            case "CallExpression":
-            case "NewExpression":
-                callSeen = true;
-                break;
-            case "Identifier":
-                if (callSeen &&
-                    (0,external_api_cjs_namespaceObject.hasProperty)(params, node.name) &&
-                    !safeArgs[params[node.name]]) {
-                    safeArgs[params[node.name]] = null;
-                }
-        }
-    });
+            return null;
+        };
+        state.stack = func.stack;
+        state.traverse(func.node.body);
+    }
+    finally {
+        state.pre = pre;
+        state.post = post;
+        state.stack = stack;
+    }
     return safeArgs;
 }
 function canInline(state, func, args) {
@@ -11434,9 +11665,6 @@ function processInlineBody(state, func, call, root, params) {
         state.pre = (node) => {
             if (failed)
                 return [];
-            node.start = call.start;
-            node.end = call.end;
-            node.loc = call.loc;
             if (replacements.has(node))
                 return false;
             const result = pre(node, state);
@@ -11451,6 +11679,7 @@ function processInlineBody(state, func, call, root, params) {
                     if (params[paramName] >= 0)
                         return null;
                     const name = renameVariable(state, locals, paramName) || paramName;
+                    locals.map[name] = true;
                     return {
                         type: "VariableDeclarator",
                         id: { type: "Identifier", name },
@@ -11469,31 +11698,49 @@ function processInlineBody(state, func, call, root, params) {
             }
             return result;
         };
+        const fixId = (node) => {
+            if (state.inType)
+                return null;
+            if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
+                const ix = params[node.name];
+                if (ix >= 0) {
+                    const replacement = { ...call.arguments[ix] };
+                    replacements.add(replacement);
+                    return replacement;
+                }
+                return null;
+            }
+            const replacement = fixNodeScope(state, node, func.stack);
+            if (!replacement) {
+                failed = true;
+                inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+            }
+            return replacement;
+        };
         state.post = (node) => {
             if (failed)
                 return post(node, state);
             let replacement = null;
             switch (node.type) {
-                case "Identifier": {
-                    if (state.inType)
-                        break;
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(params, node.name)) {
-                        const ix = params[node.name];
-                        if (ix >= 0) {
-                            replacement = { ...call.arguments[ix] };
-                            replacements.add(replacement);
-                            return replacement;
+                case "AssignmentExpression":
+                    if (node.left.type === "Identifier") {
+                        const rep = fixId(node.left);
+                        if (rep) {
+                            node.left = rep;
                         }
-                        break;
                     }
-                    replacement = fixNodeScope(state, node, func.stack);
-                    if (!replacement) {
-                        failed = true;
-                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
-                        return post(node, state);
+                    break;
+                case "UpdateExpression":
+                    if (node.argument.type === "Identifier") {
+                        const rep = fixId(node.argument);
+                        if (rep) {
+                            node.argument = rep;
+                        }
                     }
                     break;
-                }
+                case "Identifier":
+                    replacement = fixId(node);
+                    break;
             }
             const ret = post(replacement || node, state);
             return ret === false || ret ? ret : replacement;
@@ -11662,7 +11909,7 @@ function inlineWithArgs(state, func, call, context) {
             }
         }
     }
-    const body = JSON.parse(JSON.stringify(func.node.body));
+    const body = cloneDeep(func.node.body);
     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)
@@ -11711,18 +11958,19 @@ function inlineWithArgs(state, func, call, context) {
             --block.body.length;
         }
     }
+    withLocDeep(body, context, context, true);
     return body;
 }
 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 retArg = cloneDeep(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 map = fixupLocalsMap(state);
     const ret = processInlineBody(state, func, call, retArg, params);
     state.localsStack[state.localsStack.length - 1].map = map;
-    return ret;
+    return ret && withLocDeep(ret, call, call, true);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -11827,6 +12075,121 @@ function fixNodeScope(state, lookupNode, nodeStack) {
     return null;
 }
 
+;// CONCATENATED MODULE: ./src/pragma-checker.ts
+
+
+
+function pragmaChecker(state, ast, diagnostics) {
+    const comments = ast.comments;
+    if (!comments)
+        return;
+    diagnostics = diagnostics
+        ?.slice()
+        .sort((d1, d2) => d1.loc.start < d2.loc.start ? -1 : d1.loc.start == d2.loc.start ? 0 : 1);
+    let diagIndex = 0;
+    let index = -1;
+    let comment;
+    let matchers;
+    const next = () => {
+        while (++index < comments.length) {
+            comment = comments[index];
+            let match = comment.value.match(/^\s*@(match|expect)\s+(.+)/);
+            if (!match)
+                continue;
+            const kind = match[1];
+            let str = match[2];
+            matchers = [];
+            while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
+                matchers.push({ kind, 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({ kind, quote: '"', needle: match[1] });
+                    break;
+                }
+            }
+            diagnostic(state, comment.loc, `Build pragma '${comment.value}' is invalid`, "ERROR");
+        }
+    };
+    const matcher = (quote, needle, haystack) => {
+        if (quote == '"') {
+            return haystack.includes(needle);
+        }
+        const re = new RegExp(needle.replace(/@(\d+)/g, "(pre_)?$1(_\\d+)?"));
+        return re.test(haystack);
+    };
+    next();
+    traverseAst(ast, (node) => {
+        if (index >= comments.length)
+            return false;
+        if (node.start && node.start >= (comment.end || Infinity)) {
+            const { kind, quote, needle } = matchers.shift();
+            if (kind === "match") {
+                const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/([\r\n]|\s)+/g, " ");
+                if (!matcher(quote, needle, haystack)) {
+                    matcher(quote, needle, haystack);
+                    diagnostic(state, comment.loc, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
+                }
+            }
+            else if (kind === "expect") {
+                const locCmp = (a, b) => {
+                    if (!b)
+                        return -1;
+                    if (a.start.line < b.start.line)
+                        return -1;
+                    if (a.start.line === b.start.line &&
+                        a.start.column < b.start.column) {
+                        return -1;
+                    }
+                    if (a.end.line > b.end.line)
+                        return 1;
+                    if (a.end.line === b.end.line && a.end.column >= b.end.column) {
+                        return 1;
+                    }
+                    return 0;
+                };
+                let found = false;
+                if (diagnostics) {
+                    while (true) {
+                        if (diagIndex >= diagnostics.length) {
+                            diagnostics = null;
+                            break;
+                        }
+                        const diag = diagnostics[diagIndex];
+                        const cmp = locCmp(diag.loc, node.loc);
+                        if (cmp > 0) {
+                            break;
+                        }
+                        diagIndex++;
+                        if (cmp < 0)
+                            continue;
+                        if (matcher(quote, needle, diag.message)) {
+                            found = true;
+                            diag.type = "INFO";
+                        }
+                    }
+                }
+                if (!found) {
+                    diagnostic(state, comment.loc, `Missing error message '${needle}`, "ERROR");
+                }
+            }
+            if (matchers.length) {
+                // if we're checking a series of nodes, we need
+                // to skip over this one.
+                return false;
+            }
+            next();
+        }
+        return null;
+    });
+}
+
 ;// CONCATENATED MODULE: ./src/control-flow.ts
 
 
@@ -12347,6 +12710,7 @@ var priorityqueuejs = __webpack_require__(2789);
 
 
 
+
 /**
  * This implements a pseudo Partial Redundancy Elimination
  * pass. It isn't quite like traditional PRE because we're
@@ -12416,7 +12780,7 @@ function sizeBasedPRE(state, func) {
         return;
     }
     const { graph: head, identifiers } = buildPREGraph(state, func);
-    const candidates = computeAttributes(head);
+    const candidates = computeAttributes(state, head);
     if (candidates) {
         if (logging) {
             console.log(`Found ${candidates.size} candidates in ${func.fullName}`);
@@ -12436,8 +12800,10 @@ function sizeBasedPRE(state, func) {
             let i = 0;
             do {
                 name = `pre_${declName(decl)}${i ? "_" + i : ""}`;
-                if (!identifiers.has(name))
+                if (!identifiers.has(name)) {
+                    identifiers.add(name);
                     break;
+                }
                 i++;
             } while (true);
             declMap.set(decl, name);
@@ -12528,11 +12894,16 @@ function buildPREGraph(state, func) {
                 case "ParenthesizedExpression":
                     break;
                 case "Literal":
-                    if (!node.value && refCost(node) > LocalRefCost) {
-                        let decl = literals.get(node.value);
+                    if (refCost(node) > LocalRefCost) {
+                        const result = getNodeValue(node);
+                        const key = result[1] +
+                            (result[0].value === null
+                                ? ""
+                                : "-" + result[0].value.toString());
+                        let decl = literals.get(key);
                         if (!decl) {
                             decl = node;
-                            literals.set(node.value, decl);
+                            literals.set(key, decl);
                         }
                         return {
                             type: "ref",
@@ -12612,10 +12983,18 @@ function buildPREGraph(state, func) {
                     }
                     break;
                 }
-                case "NewExpression":
-                case "CallExpression":
+                case "NewExpression": {
+                    const [, results] = state.lookup(node.callee);
+                    const callees = results ? findCalleesForNew(results) : null;
+                    liveDef(null, stmt);
+                    return { type: "mod", node, mayThrow, callees };
+                }
+                case "CallExpression": {
                     liveDef(null, stmt);
-                    return { type: "mod", node, mayThrow };
+                    const [, results] = state.lookup(node.callee);
+                    const callees = results ? findCallees(results) : null;
+                    return { type: "mod", node, mayThrow, callees };
+                }
                 default:
                     if (!isExpression(node))
                         break;
@@ -12631,12 +13010,6 @@ function buildPREGraph(state, func) {
 function anticipatedDecls() {
     return new Map();
 }
-function cloneSet(ae) {
-    return new Set(ae);
-}
-function mergeSet(a, b) {
-    b.forEach((event) => a.add(event));
-}
 function equalSet(a, b) {
     if (a.size != b.size)
         return false;
@@ -12715,6 +13088,7 @@ function refCost(node) {
         switch (typeof node.value) {
             case "string":
                 return 5;
+            case "bigint":
             case "number":
                 return 5;
             case "boolean":
@@ -12776,7 +13150,7 @@ function candidateCost(candState) {
     cost += defCost(candState.node) * boundarySize;
     return cost;
 }
-function computeAttributes(head) {
+function computeAttributes(state, head) {
     const order = getPostOrder(head);
     order.forEach((block, i) => {
         block.order = i;
@@ -12885,7 +13259,9 @@ function computeAttributes(head) {
                         curState.forEach((candidates, decl) => {
                             if (decl.type === "VariableDeclarator" &&
                                 decl.node.kind === "var" &&
-                                candidates.live) {
+                                candidates.live &&
+                                (!event.callees ||
+                                    event.callees.some((callee) => functionMayModify(state, callee, decl)))) {
                                 candidates.ant.add(getMod(event, decl, candidates.node));
                                 candidates.live = false;
                             }
@@ -13074,20 +13450,26 @@ function applyReplacements(func, nodeMap, declMap) {
             stmtStack.pop();
         const events = nodeMap.get(node);
         if (events) {
-            if (events.length === 1) {
-                if (events[0].type === "ref") {
+            const ret = events.reduce((ret, event) => {
+                if (event.type === "ref") {
+                    if (ret) {
+                        throw new Error(`ref found when there was already a replacement for this node`);
+                    }
                     if (node.type !== "Identifier" &&
                         node.type !== "MemberExpression" &&
                         node.type !== "Literal") {
                         throw new Error(`Ref found, but wrong type of node: ${node.type}`);
                     }
-                    const name = declMap.get(events[0].decl);
+                    const name = declMap.get(event.decl);
                     if (!name) {
                         throw new Error(`No replacement found for "${(0,external_api_cjs_namespaceObject.formatAst)(node)}"`);
                     }
                     return ident(name, node);
                 }
-                else if (events[0].type === "def") {
+                if (event.type === "def") {
+                    if (ret) {
+                        throw new Error(`def found when there was already a replacement for this node`);
+                    }
                     if (node.type !== "AssignmentExpression" &&
                         node.type !== "UpdateExpression") {
                         throw new Error(`Def found, but wrong type of node: ${node.type}`);
@@ -13095,7 +13477,7 @@ function applyReplacements(func, nodeMap, declMap) {
                     const target = node.type === "AssignmentExpression"
                         ? node.left
                         : node.argument;
-                    const name = declMap.get(events[0].decl);
+                    const name = declMap.get(event.decl);
                     if (!name) {
                         throw new Error(`No replacement found for "${(0,external_api_cjs_namespaceObject.formatAst)(target)}"`);
                     }
@@ -13114,20 +13496,24 @@ function applyReplacements(func, nodeMap, declMap) {
                     }
                     return withLoc({ type: "SequenceExpression", expressions: [node, assign] }, node);
                 }
-            }
-            events.forEach((event) => {
-                if (event.type !== "mod") {
-                    throw new Error(`Unexpected ${event.type} found amongst multiple events`);
-                }
-                if (!event.decl) {
-                    throw new Error(`Unexpected null decl on mod event`);
+                if (event.type === "mod") {
+                    if (!event.decl) {
+                        throw new Error(`Unexpected null decl on mod event`);
+                    }
+                    let pending = pendingMap.get(stmt);
+                    if (!pending) {
+                        pendingMap.set(stmt, (pending = new Set()));
+                    }
+                    pending.add(event);
                 }
-                let pending = pendingMap.get(stmt);
-                if (!pending) {
-                    pendingMap.set(stmt, (pending = new Set()));
+                else {
+                    throw new Error(`Unexpected ${event.type} found`);
                 }
-                pending.add(event);
-            });
+                return ret;
+            }, null);
+            if (ret) {
+                return ret;
+            }
         }
         const pending = pendingMap.get(node);
         if (node.type === "SequenceExpression") {
@@ -13201,6 +13587,148 @@ function applyReplacements(func, nodeMap, declMap) {
     });
 }
 
+;// CONCATENATED MODULE: ./src/unused-exprs.ts
+
+
+
+function cleanupUnusedVars(state, node) {
+    const [parent] = state.stack.slice(-1);
+    if (parent.node !== node) {
+        return;
+    }
+    if (parent.type != "BlockStatement") {
+        throw new Error(`Unexpected parent type '${parent.type}' for local declaration`);
+    }
+    if (parent.decls) {
+        let toRemove = null;
+        Object.values(parent.decls).forEach((decls) => {
+            if (decls.length === 1 &&
+                decls[0].type === "VariableDeclarator" &&
+                !decls[0].used) {
+                if (!toRemove)
+                    toRemove = {};
+                toRemove[decls[0].name] = decls[0];
+            }
+        });
+        if (toRemove) {
+            const varDeclarations = new Map();
+            traverseAst(node, null, (node) => {
+                switch (node.type) {
+                    case "VariableDeclaration": {
+                        node.declarations.forEach((decl, i) => {
+                            const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(decl.id);
+                            if (hasProperty(toRemove, name)) {
+                                const indices = varDeclarations.get(node);
+                                if (indices) {
+                                    indices.push(i);
+                                }
+                                else {
+                                    varDeclarations.set(node, [i]);
+                                }
+                            }
+                        });
+                        break;
+                    }
+                    case "ExpressionStatement":
+                        if (node.expression.type === "AssignmentExpression") {
+                            if (node.expression.left.type === "Identifier" &&
+                                hasProperty(toRemove, node.expression.left.name)) {
+                                return unused(node.expression.right);
+                            }
+                        }
+                        else if (node.expression.type === "UpdateExpression" &&
+                            node.expression.argument.type === "Identifier" &&
+                            hasProperty(toRemove, node.expression.argument.name)) {
+                            return false;
+                        }
+                        break;
+                    case "SequenceExpression": {
+                        for (let i = node.expressions.length; i--;) {
+                            const expr = node.expressions[i];
+                            if (expr.type === "AssignmentExpression") {
+                                if (expr.left.type === "Identifier" &&
+                                    hasProperty(toRemove, expr.left.name)) {
+                                    const rep = unused(expr.right);
+                                    if (!rep.length) {
+                                        node.expressions.splice(i, 1);
+                                    }
+                                    else {
+                                        // Sequence expressions can only be assignments
+                                        // or update expressions. Even calls aren't allowed
+                                        toRemove[expr.left.name] = null;
+                                        expr.operator = "=";
+                                    }
+                                }
+                            }
+                            else if (expr.type === "UpdateExpression" &&
+                                expr.argument.type === "Identifier" &&
+                                hasProperty(toRemove, expr.argument.name)) {
+                                node.expressions.splice(i, 1);
+                            }
+                        }
+                        break;
+                    }
+                }
+                return null;
+            });
+            varDeclarations.forEach((indices, decl) => {
+                let index = -1;
+                for (let ii = indices.length, j = decl.declarations.length; ii--;) {
+                    const i = indices[ii];
+                    const vdecl = decl.declarations[i];
+                    const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(vdecl.id);
+                    if (hasProperty(toRemove, name)) {
+                        const rep = vdecl.init ? unused(vdecl.init) : [];
+                        if (rep.length) {
+                            if (parent.node.type === "ForStatement") {
+                                // declarations whose inits have side effects
+                                // can't be deleted from for statements.
+                                continue;
+                            }
+                            if (index < 0) {
+                                index = parent.node.body.findIndex((s) => s === decl);
+                                if (index < 0) {
+                                    throw new Error(`Failed to find variable declaration for ${(0,external_api_cjs_namespaceObject.variableDeclarationName)(vdecl.id)}`);
+                                }
+                            }
+                            if (j > i + 1) {
+                                const tail = {
+                                    ...decl,
+                                    declarations: decl.declarations.slice(i + 1, j),
+                                };
+                                if (decl.loc && vdecl.loc) {
+                                    tail.loc = { ...decl.loc, start: vdecl.loc.end };
+                                    tail.start = vdecl.end;
+                                }
+                                rep.push(tail);
+                            }
+                            if (decl.loc && vdecl.loc) {
+                                decl.loc = { ...decl.loc, end: vdecl.loc.start };
+                                decl.end = vdecl.start;
+                            }
+                            decl.declarations.splice(i);
+                            parent.node.body.splice(index + 1, 0, ...rep);
+                            j = i;
+                            continue;
+                        }
+                        if (toRemove[name]) {
+                            j--;
+                            decl.declarations.splice(i, 1);
+                            if (i === j && decl.loc && vdecl.loc) {
+                                decl.loc = { ...decl.loc, end: vdecl.loc.start };
+                                decl.end = vdecl.start;
+                            }
+                        }
+                        else {
+                            delete vdecl.init;
+                        }
+                    }
+                }
+            });
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/visitor.ts
 
 function visitReferences(state, ast, name, defn, callback) {
@@ -13265,14 +13793,16 @@ function visitReferences(state, ast, name, defn, callback) {
                     return checkResults(state.lookup(node), node);
                 }
                 break;
-            case "MemberExpression":
-                if (!node.computed && node.property.type === "Identifier") {
-                    if (!name || node.property.name === name) {
+            case "MemberExpression": {
+                const property = (0,external_api_cjs_namespaceObject.isLookupCandidate)(node);
+                if (property) {
+                    if (!name || property.name === name) {
                         return checkResults(state.lookup(node), node) || ["object"];
                     }
                     return ["object"];
                 }
                 break;
+            }
             case "MethodDefinition": {
                 if (!state.inType) {
                     throw new Error("Method definition outside of type!");
@@ -13281,7 +13811,6 @@ function visitReferences(state, ast, name, defn, callback) {
                     node.params.forEach((param) => {
                         if (param.type == "BinaryExpression") {
                             state.traverse(param.right);
-                            state.inType = true;
                         }
                     });
                 }
@@ -13304,6 +13833,9 @@ function visitReferences(state, ast, name, defn, callback) {
 
 
 
+
+
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -13363,8 +13895,7 @@ function collectClassInfo(state) {
             c.decls &&
                 Object.values(c.decls).forEach((funcs) => {
                     funcs.forEach((f) => {
-                        if ((0,external_api_cjs_namespaceObject.isStateNode)(f) &&
-                            f.type === "FunctionDeclaration" &&
+                        if (f.type === "FunctionDeclaration" &&
                             (0,external_api_cjs_namespaceObject.hasProperty)(cls.decls, f.name)) {
                             f.node.hasOverride = true;
                         }
@@ -13377,6 +13908,15 @@ function collectClassInfo(state) {
     state.allClasses.forEach((elm) => {
         if (elm.superClass)
             markOverrides(elm, elm.superClass);
+        if (elm.hasInvoke && elm.decls) {
+            Object.values(elm.decls).forEach((funcs) => {
+                funcs.forEach((f) => {
+                    if (f.type === "FunctionDeclaration" && !f.isStatic) {
+                        (0,external_api_cjs_namespaceObject.markInvokeClassMethod)(f);
+                    }
+                });
+            });
+        }
     });
 }
 function getFileSources(fnMap) {
@@ -13415,7 +13955,7 @@ async function analyze(fnMap, barrelList, config) {
     const preState = {
         fnMap,
         config,
-        allFunctions: [],
+        allFunctions: {},
         allClasses: [],
         shouldExclude(node) {
             if ("attrs" in node &&
@@ -13445,11 +13985,6 @@ async function analyze(fnMap, barrelList, config) {
         pre(node, state) {
             switch (node.type) {
                 case "FunctionDeclaration":
-                    if (markApi) {
-                        node.body = null;
-                        break;
-                    }
-                // falls through
                 case "ModuleDeclaration":
                 case "ClassDeclaration": {
                     const [scope] = state.stack.slice(-1);
@@ -13460,7 +13995,18 @@ async function analyze(fnMap, barrelList, config) {
                                 (scope.node.attrs &&
                                     scope.node.attrs.access &&
                                     scope.node.attrs.access.includes("static"));
-                        state.allFunctions.push(scope);
+                        if (markApi) {
+                            node.body = null;
+                            scope.info = (0,external_api_cjs_namespaceObject.getApiFunctionInfo)(scope);
+                            delete scope.stack;
+                        }
+                        const allFuncs = state.allFunctions;
+                        if (!(0,external_api_cjs_namespaceObject.hasProperty)(allFuncs, scope.name)) {
+                            allFuncs[scope.name] = [scope];
+                        }
+                        else {
+                            allFuncs[scope.name].push(scope);
+                        }
                     }
                     else if (scope.type === "ClassDeclaration") {
                         state.allClasses.push(scope);
@@ -13485,7 +14031,7 @@ async function analyze(fnMap, barrelList, config) {
         value.hasTests = hasTests;
     });
     delete state.shouldExclude;
-    delete state.post;
+    delete state.pre;
     collectClassInfo(state);
     const diagnosticType = config?.checkInvalidSymbols !== "OFF"
         ? config?.checkInvalidSymbols || "WARNING"
@@ -13508,6 +14054,8 @@ async function analyze(fnMap, barrelList, config) {
             });
         });
     }
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
     return state;
 }
 function compareLiteralLike(a, b) {
@@ -13553,57 +14101,16 @@ function getLiteralNode(node) {
         if (node.argument.type != "Literal")
             return null;
         switch (node.operator) {
-            case "-":
-                if (typeof node.argument.value == "number") {
-                    return {
-                        ...node.argument,
-                        value: -node.argument.value,
-                        raw: "-" + node.argument.value,
-                        enumType: node.enumType,
-                    };
+            case "-": {
+                const [arg, type] = getNodeValue(node.argument);
+                if (type === "Number" || type === "Long") {
+                    return replacementLiteral(arg, -arg.value, type);
                 }
+            }
         }
     }
     return null;
 }
-function getNodeValue(node) {
-    if (node.type == "BinaryExpression" &&
-        node.operator == "as" &&
-        node.right.type == "TypeSpecList" &&
-        node.right.ts.length == 1 &&
-        typeof node.right.ts[0] == "string") {
-        // this is a cast we inserted to retain the type of an enum
-        // any arithmetic on it will revert to "Number", or "Long",
-        // so just ignore it.
-        return getNodeValue(node.left);
-    }
-    if (node.type != "Literal") {
-        return [null, null];
-    }
-    let type = node.value === null ? "Null" : typeof node.value;
-    if (type === "number") {
-        const match = node.raw && prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
-        if (match) {
-            type = match[2] == "l" ? "Long" : "Number";
-        }
-        else if (node.raw && node.raw.endsWith("d")) {
-            type = "Double";
-        }
-        else {
-            type = "Float";
-        }
-    }
-    else if (type === "string") {
-        type = "String";
-    }
-    else if (type === "boolean") {
-        type = "Boolean";
-    }
-    else {
-        type = "Unknown";
-    }
-    return [node, type];
-}
 function fullTypeName(state, tsp) {
     if (typeof tsp.name === "string") {
         return tsp.name;
@@ -13647,6 +14154,46 @@ function isBooleanExpression(state, node) {
     }
     return false;
 }
+function replacementLiteral(arg, value, type) {
+    if (typeof value === "boolean") {
+        type = "Boolean";
+    }
+    else if (type === "Number") {
+        value = Number(BigInt.asIntN(32, BigInt(value)));
+    }
+    else if (type === "Long") {
+        value = BigInt.asIntN(64, BigInt(value));
+    }
+    return {
+        ...arg,
+        value,
+        raw: value.toString() + (type === "Long" ? "l" : ""),
+    };
+}
+const operators = {
+    "+": (left, right) => left + right,
+    "-": (left, right) => left - right,
+    "*": (left, right) => left * right,
+    "/": (left, right) => left / right,
+    "%": (left, right) => left % right,
+    "&": (left, right) => left & right,
+    "|": (left, right) => left | right,
+    "^": (left, right) => left ^ right,
+    "<<": (left, right) => left << (right & 127n),
+    ">>": (left, right) => left >> (right & 127n),
+    "==": (left, right) => 
+    // two string literals will compare unequal, becuase string
+    // equality is object equality.
+    typeof left === "string" ? false : left === right,
+    "!=": (left, right) => typeof left === "string" ? true : left !== right,
+    "<=": (left, right) => left <= right,
+    ">=": (left, right) => left >= right,
+    "<": (left, right) => left < right,
+    ">": (left, right) => left > right,
+    as: null,
+    instanceof: null,
+    has: null,
+};
 function optimizeNode(state, node) {
     switch (node.type) {
         case "UnaryExpression": {
@@ -13661,29 +14208,17 @@ function optimizeNode(state, node) {
                     break;
                 case "-":
                     if (type === "Number" || type === "Long") {
-                        return {
-                            ...arg,
-                            value: -arg.value,
-                            raw: (-arg.value).toString() + (type === "Long" ? "l" : ""),
-                        };
+                        return replacementLiteral(arg, -arg.value, type);
                     }
                     break;
                 case "!":
                 case "~":
                     {
-                        let value;
                         if (type === "Number" || type === "Long") {
-                            value = -arg.value - 1;
+                            return replacementLiteral(arg, ~BigInt(arg.value), type);
                         }
-                        else if (type === "Boolean" && node.operator == "!") {
-                            value = !arg.value;
-                        }
-                        if (value !== undefined) {
-                            return {
-                                ...arg,
-                                value,
-                                raw: value.toString() + (type === "Long" ? "l" : ""),
-                            };
+                        if (type === "Boolean" && node.operator == "!") {
+                            return replacementLiteral(arg, !arg.value, type);
                         }
                     }
                     break;
@@ -13691,27 +14226,6 @@ function optimizeNode(state, node) {
             break;
         }
         case "BinaryExpression": {
-            const operators = {
-                "+": (left, right) => left + right,
-                "-": (left, right) => left - right,
-                "*": (left, right) => left * right,
-                "/": (left, right) => Math.trunc(left / right),
-                "%": (left, right) => left % right,
-                "&": (left, right, type) => type === "Number" ? left & right : null,
-                "|": (left, right, type) => type === "Number" ? left | right : null,
-                "^": (left, right, type) => type === "Number" ? left ^ right : null,
-                "<<": (left, right, type) => type === "Number" ? left << right : null,
-                ">>": (left, right, type) => type === "Number" ? left >> right : null,
-                "==": (left, right) => left == right,
-                "!=": (left, right) => left != right,
-                "<=": (left, right) => left <= right,
-                ">=": (left, right) => left >= right,
-                "<": (left, right) => left < right,
-                ">": (left, right) => left > right,
-                as: null,
-                instanceof: null,
-                has: null,
-            };
             const op = operators[node.operator];
             if (op) {
                 const [left, left_type] = getNodeValue(node.left);
@@ -13719,23 +14233,22 @@ function optimizeNode(state, node) {
                 if (!left || !right)
                     break;
                 let value = null;
-                if (left_type != right_type ||
-                    (left_type != "Number" && left_type != "Long")) {
+                let type;
+                if ((left_type != "Number" && left_type != "Long") ||
+                    left_type != right_type) {
                     if (node.operator !== "==" && node.operator !== "!=") {
                         break;
                     }
                     value = operators[node.operator](left.value, right.value);
+                    type = "Boolean";
                 }
                 else {
-                    value = op(left.value, right.value, left_type);
+                    type = left_type;
+                    value = op(BigInt(left.value), BigInt(right.value));
                 }
                 if (value === null)
                     break;
-                return {
-                    ...left,
-                    value,
-                    raw: value.toString() + (left_type === "Long" ? "l" : ""),
-                };
+                return replacementLiteral(left, value, type);
             }
             break;
         }
@@ -13745,7 +14258,8 @@ function optimizeNode(state, node) {
                 break;
             const falsy = left.value === false ||
                 left.value === null ||
-                (left.value === 0 && (left_type === "Number" || left_type === "Long"));
+                ((left_type === "Number" || left_type === "Long") &&
+                    (left.value === 0 || left.value === 0n));
             if (falsy === (node.operator === "&&")) {
                 return left;
             }
@@ -13786,9 +14300,7 @@ function evaluateFunction(state, func, args) {
     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 ? cloneDeep(func.body) : func.body;
     try {
         traverseAst(body, (node) => {
             switch (node.type) {
@@ -13839,12 +14351,10 @@ function markFunctionCalled(state, func) {
     (0,external_util_cjs_namespaceObject.pushUnique)(state.calledFunctions[func.id.name], func);
 }
 async function optimizeMonkeyC(fnMap, barrelList, config) {
-    const state = {
-        ...(await analyze(fnMap, barrelList, config)),
-        localsStack: [{}],
-        exposed: {},
-        calledFunctions: {},
-    };
+    const state = (await analyze(fnMap, barrelList, config));
+    state.localsStack = [{}];
+    state.calledFunctions = {};
+    state.usedByName = {};
     const replace = (node, old) => {
         if (node === false || node === null)
             return node;
@@ -13933,6 +14443,58 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     f.type == "FunctionDeclaration" &&
                     maybeCalled(f.node))) ||
                 (sc.superClass && checkInherited(sc, name))));
+    const renamer = (idnode) => {
+        const ident = idnode.type === "Identifier" ? idnode : idnode.left;
+        const locals = topLocals();
+        const { map } = locals;
+        if (map) {
+            const declName = ident.name;
+            const name = renameVariable(state, locals, declName);
+            if (name) {
+                const [, results] = state.lookupValue(ident);
+                if (!results) {
+                    throw new Error(`Didn't find local ${declName} which needed renaming`);
+                }
+                if (results.length !== 1) {
+                    throw new Error(`Lookup of local ${declName} found more than one result`);
+                }
+                const parent = results[0].parent;
+                if (!parent) {
+                    throw new Error(`No parent in lookup of local ${declName}`);
+                }
+                const decls = parent.decls;
+                if (!decls || !(0,external_api_cjs_namespaceObject.hasProperty)(decls, declName)) {
+                    throw new Error(`Missing decls in lookup of local ${declName}`);
+                }
+                if ((0,external_api_cjs_namespaceObject.hasProperty)(decls, name)) {
+                    throw new Error(`While renaming ${declName} to ${name}, there was already a variable ${name}`);
+                }
+                if (decls[declName].length === 1) {
+                    decls[name] = decls[declName];
+                    delete decls[declName];
+                }
+                else {
+                    let i = decls[declName].length;
+                    while (i--) {
+                        const decl = decls[declName][i];
+                        if (decl === idnode ||
+                            (decl.type === "VariableDeclarator" && decl.node.id === idnode)) {
+                            decls[declName].splice(i, 1);
+                            decls[name] = [decl];
+                            break;
+                        }
+                    }
+                    if (i < 0) {
+                        throw new Error(`While renaming ${declName} to ${name}: Didn't find original declaration`);
+                    }
+                }
+                ident.name = name;
+            }
+            else {
+                map[declName] = true;
+            }
+        }
+    };
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
@@ -13953,7 +14515,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         result = !!value.value;
                     }
                     if (result !== null) {
-                        node.test = { type: "Literal", value: result };
+                        node.test = {
+                            type: "Literal",
+                            value: result,
+                            raw: result.toString(),
+                        };
                         if (node.type === "IfStatement" ||
                             node.type === "ConditionalExpression") {
                             return [result ? "consequent" : "alternate"];
@@ -13972,7 +14538,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 return null;
             }
             case "EnumDeclaration":
-                return false;
+                return [];
             case "ForStatement": {
                 const map = topLocals().map;
                 if (map) {
@@ -13981,43 +14547,13 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             }
             case "VariableDeclarator": {
-                const locals = topLocals();
-                const { map } = locals;
-                if (map) {
-                    const declName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id);
-                    const name = renameVariable(state, locals, declName);
-                    if (name) {
-                        if (node.id.type === "Identifier") {
-                            node.id.name = name;
-                        }
-                        else {
-                            node.id.left.name = name;
-                        }
-                    }
-                    else {
-                        map[declName] = true;
-                    }
-                }
+                renamer(node.id);
                 return ["init"];
             }
             case "CatchClause":
                 if (node.param) {
                     state.localsStack.push({ node, map: { ...(topLocals().map || {}) } });
-                    const locals = topLocals();
-                    const map = locals.map;
-                    const declName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(node.param);
-                    const name = renameVariable(state, locals, declName);
-                    if (name) {
-                        if (node.param.type === "Identifier") {
-                            node.param.name = name;
-                        }
-                        else {
-                            node.param.left.name = name;
-                        }
-                    }
-                    else {
-                        map[declName] = true;
-                    }
+                    renamer(node.param);
                     return ["body"];
                 }
                 break;
@@ -14033,14 +14569,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             case "UnaryExpression":
                 if (node.operator == ":") {
-                    // If we produce a Symbol, for a given name,
-                    // its possible that someone uses that symbol
-                    // indirectly, so we can't remove any enums or
-                    // constants with that name (we can still replace
-                    // uses of those constants though).
-                    state.exposed[node.argument.name] = true;
-                    // In any case, we can't replace *this* use of the
-                    // symbol with its value...
+                    // node.argument is not a normal identifier.
+                    // don't visit it.
                     return [];
                 }
                 break;
@@ -14052,29 +14582,73 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         if (typeof name === "string") {
                             node.name = name;
                         }
+                        const [, results] = state.lookupValue(node);
+                        if (results) {
+                            if (results.length !== 1 || results[0].results.length !== 1) {
+                                throw new Error(`Local ${node.name} had multiple lookup results`);
+                            }
+                            const parent = results[0].parent;
+                            if (!parent) {
+                                throw new Error(`Local ${node.name} had no parent`);
+                            }
+                            const decl = results[0].results[0];
+                            if (parent.type === "FunctionDeclaration" ||
+                                decl.type !== "VariableDeclarator") {
+                                // we can't optimize away function or catch parameters
+                                return [];
+                            }
+                            if (parent.type !== "BlockStatement") {
+                                throw new Error(`Local ${node.name} was not declared at block scope(??)`);
+                            }
+                            decl.used = true;
+                        }
                     }
                 }
                 if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.name)) {
                     if (!lookupAndReplace(node)) {
-                        state.exposed[node.name] = true;
+                        state.usedByName[node.name] = true;
                     }
                 }
                 return [];
             }
-            case "MemberExpression":
-                if (node.property.type === "Identifier" && !node.computed) {
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.property.name)) {
+            case "MemberExpression": {
+                const property = (0,external_api_cjs_namespaceObject.isLookupCandidate)(node);
+                if (property) {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, property.name)) {
                         if (lookupAndReplace(node)) {
                             return false;
                         }
                         else {
-                            state.exposed[node.property.name] = true;
+                            state.usedByName[property.name] = true;
                         }
                     }
                     // Don't optimize the property.
                     return ["object"];
                 }
                 break;
+            }
+            case "AssignmentExpression":
+            case "UpdateExpression": {
+                const lhs = node.type === "AssignmentExpression" ? node.left : node.argument;
+                if (lhs.type === "Identifier") {
+                    const map = topLocals().map;
+                    if (map) {
+                        if ((0,external_api_cjs_namespaceObject.hasProperty)(map, lhs.name)) {
+                            const name = map[lhs.name];
+                            if (typeof name === "string") {
+                                lhs.name = name;
+                            }
+                        }
+                    }
+                }
+                else if (lhs.type === "MemberExpression") {
+                    state.traverse(lhs.object);
+                    if (lhs.computed) {
+                        state.traverse(lhs.property);
+                    }
+                }
+                return node.type === "AssignmentExpression" ? ["right"] : [];
+            }
             case "BlockStatement": {
                 const map = topLocals().map;
                 if (map) {
@@ -14090,7 +14664,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 node.params &&
                     node.params.forEach((p) => (map[(0,external_api_cjs_namespaceObject.variableDeclarationName)(p)] = true));
                 state.localsStack.push({ node, map });
-                const [parent] = state.stack.slice(-2);
+                const [parent, self] = state.stack.slice(-2);
+                if (state.currentFunction) {
+                    throw new Error(`Nested functions: ${self.fullName} was activated during processing of ${state.currentFunction.fullName}`);
+                }
+                state.currentFunction = self;
                 if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
                     let used = false;
                     if (node.id.name == "initialize") {
@@ -14117,10 +14695,23 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             return replace(opt, node);
         }
         switch (node.type) {
+            case "FunctionDeclaration":
+                if (!state.currentFunction) {
+                    throw new Error(`Finished function ${state.stack.slice(-1)[0].fullName}, but it was not marked current`);
+                }
+                state.currentFunction.info = state.currentFunction.next_info;
+                delete state.currentFunction.next_info;
+                delete state.currentFunction;
+                break;
             case "BlockStatement":
                 if (node.body.length === 1 && node.body[0].type === "BlockStatement") {
                     node.body.splice(0, 1, ...node.body[0].body);
                 }
+            // fall through
+            case "ForStatement":
+                if (locals.map) {
+                    cleanupUnusedVars(state, node);
+                }
                 break;
             case "ConditionalExpression":
             case "IfStatement":
@@ -14153,17 +14744,20 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     return replace(optimizeCall(state, node.argument, node), node.argument);
                 }
                 break;
+            case "NewExpression":
+                if (state.currentFunction) {
+                    const [, results] = state.lookup(node.callee);
+                    if (results) {
+                        recordCalledFuncs(state.currentFunction, findCalleesForNew(results));
+                    }
+                    else {
+                        recordModifiedUnknown(state.currentFunction);
+                    }
+                }
+                break;
             case "CallExpression": {
                 return replace(optimizeCall(state, node, null), node);
             }
-            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 "VariableDeclaration": {
                 const locals = topLocals();
                 if (locals.map &&
@@ -14237,6 +14831,32 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     }
                 }
                 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" };
+                }
+            // fall through;
+            case "UpdateExpression":
+                if (state.currentFunction) {
+                    const lhs = node.type === "AssignmentExpression" ? node.left : node.argument;
+                    const [, results] = state.lookup(lhs);
+                    if (results) {
+                        recordModifiedDecls(state.currentFunction, results);
+                    }
+                    else {
+                        const id = lhs.type === "Identifier" ? lhs : (0,external_api_cjs_namespaceObject.isLookupCandidate)(lhs);
+                        if (id) {
+                            recordModifiedName(state.currentFunction, id.name);
+                        }
+                        else {
+                            recordModifiedUnknown(state.currentFunction);
+                        }
+                    }
+                }
+                break;
         }
         return null;
     };
@@ -14244,13 +14864,16 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
     state.calledFunctions = {};
-    state.exposed = {};
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
+    state.exposed = state.nextExposed;
+    state.nextExposed = {};
     delete state.pre;
     delete state.post;
-    state.allFunctions.forEach((fn) => sizeBasedPRE(state, fn));
+    Object.values(state.allFunctions).forEach((fns) => fns.forEach((fn) => sizeBasedPRE(state, fn)));
     const cleanup = (node) => {
         switch (node.type) {
             case "ThisExpression":
@@ -14260,7 +14883,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 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));
+                        !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name) &&
+                        !(0,external_api_cjs_namespaceObject.hasProperty)(state.usedByName, name));
                 })) {
                     node.enumType = [
                         ...new Set(node.members.map((m) => {
@@ -14303,7 +14927,9 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             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));
+                    return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) ||
+                        (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name) ||
+                        (0,external_api_cjs_namespaceObject.hasProperty)(state.usedByName, name));
                 });
                 if (!node.declarations.length) {
                     return false;
@@ -14317,6 +14943,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                 break;
             case "FunctionDeclaration":
                 if (!maybeCalled(node)) {
+                    if (node.attrs &&
+                        node.attrs.attributes &&
+                        node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" && attr.argument.name === "keep")) {
+                        break;
+                    }
                     return false;
                 }
                 break;
@@ -14336,7 +14967,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
         }
         return null;
     };
-    Object.values(fnMap).forEach((f) => {
+    Object.entries(fnMap).forEach(([name, f]) => {
         traverseAst(f.ast, undefined, (node) => {
             const ret = cleanup(node);
             if (ret === false) {
@@ -14344,16 +14975,15 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
             }
             return ret;
         });
+        if (state.config && state.config.checkBuildPragmas) {
+            pragmaChecker(state, f.ast, state.diagnostics?.[name]);
+        }
     });
     return state.diagnostics;
 }
 function optimizeCall(state, node, context) {
     const [name, results] = state.lookupNonlocal(node.callee);
-    const callees = results &&
-        results
-            .map((r) => r.results)
-            .flat()
-            .filter((c) => c.type === "FunctionDeclaration");
+    const callees = results ? findCallees(results) : null;
     if (!callees || !callees.length) {
         const n = name ||
             ("name" in node.callee && node.callee.name) ||
@@ -14362,14 +14992,24 @@ function optimizeCall(state, node, context) {
                 "name" in node.callee.property &&
                 node.callee.property.name);
         if (n) {
-            state.exposed[n] = true;
+            if ((0,external_api_cjs_namespaceObject.hasProperty)(state.allFunctions, n)) {
+                if (state.currentFunction) {
+                    recordCalledFuncs(state.currentFunction, state.allFunctions[n]);
+                }
+                state.allFunctions[n].forEach((fn) => markFunctionCalled(state, fn.node));
+            }
         }
-        else {
-            // There are unnamed CallExpressions, such as new [size]
-            // So there's nothing to do here.
+        else if (state.currentFunction) {
+            // I don't think this can happen: foo[x](args)
+            // doesn't parse, so you can't even do things like
+            // $.Toybox.Lang[:format]("fmt", [])
+            recordModifiedUnknown(state.currentFunction);
         }
         return null;
     }
+    if (state.currentFunction) {
+        recordCalledFuncs(state.currentFunction, callees);
+    }
     if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
         const callee = callees[0].node;
         if (!context &&
@@ -14392,120 +15032,6 @@ function optimizeCall(state, node, context) {
     return null;
 }
 
-;// CONCATENATED MODULE: ./src/pragma-checker.ts
-
-
-function pragmaChecker(ast, diagnostics) {
-    const comments = ast.comments;
-    if (!comments)
-        return;
-    diagnostics = diagnostics
-        ?.slice()
-        .sort((d1, d2) => d1.loc.start < d2.loc.start ? -1 : d1.loc.start == d2.loc.start ? 0 : 1);
-    let diagIndex = 0;
-    let index = -1;
-    let comment;
-    let matchers;
-    const next = () => {
-        while (++index < comments.length) {
-            comment = comments[index];
-            let match = comment.value.match(/^\s*@(match|expect)\s+(.+)/);
-            if (!match)
-                continue;
-            const kind = match[1];
-            let str = match[2];
-            matchers = [];
-            while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
-                matchers.push({ kind, 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({ kind, quote: '"', needle: match[1] });
-                    break;
-                }
-            }
-            throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
-        }
-    };
-    const matcher = (quote, needle, haystack) => {
-        if (quote == '"') {
-            return haystack.includes(needle);
-        }
-        const re = new RegExp(needle.replace(/@(\d+)/g, "(pre_)?$1(_\\d+)?"));
-        return re.test(haystack);
-    };
-    next();
-    traverseAst(ast, (node) => {
-        if (index >= comments.length)
-            return false;
-        if (node.start && node.start >= (comment.end || Infinity)) {
-            const { kind, quote, needle } = matchers.shift();
-            if (kind === "match") {
-                const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/([\r\n]|\s)+/g, " ");
-                if (!matcher(quote, needle, haystack)) {
-                    matcher(quote, needle, haystack);
-                    throw new Error(`Didn't find '${needle}' in '${haystack}' at ${comment.loc.source}:${comment.loc.start.line}`);
-                }
-            }
-            else if (kind === "expect") {
-                const locCmp = (a, b) => {
-                    if (!b)
-                        return -1;
-                    if (a.start.line < b.start.line)
-                        return -1;
-                    if (a.start.line === b.start.line &&
-                        a.start.column < b.start.column) {
-                        return -1;
-                    }
-                    if (a.end.line > b.end.line)
-                        return 1;
-                    if (a.end.line === b.end.line && a.end.column >= b.end.column) {
-                        return 1;
-                    }
-                    return 0;
-                };
-                let found = false;
-                if (diagnostics) {
-                    while (true) {
-                        if (diagIndex >= diagnostics.length) {
-                            diagnostics = null;
-                            break;
-                        }
-                        const diag = diagnostics[diagIndex];
-                        const cmp = locCmp(diag.loc, node.loc);
-                        if (cmp > 0) {
-                            break;
-                        }
-                        diagIndex++;
-                        if (cmp < 0)
-                            continue;
-                        if (matcher(quote, needle, diag.message)) {
-                            found = true;
-                            diag.type = "INFO";
-                        }
-                    }
-                }
-                if (!found) {
-                    throw new Error(`Missing error message '${needle} at ${comment.loc.source}:${comment.loc.start.line}`);
-                }
-            }
-            if (matchers.length) {
-                // if we're checking a series of nodes, we need
-                // to skip over this one.
-                return false;
-            }
-            next();
-        }
-        return null;
-    });
-}
-
 ;// CONCATENATED MODULE: ./src/optimizer.ts
 
 
@@ -14943,22 +15469,19 @@ 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 && 1656860602542 < opt_time) {
+        if (source_time < opt_time && 1658088370253 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
     await promises_namespaceObject.rm(output, { recursive: true, force: true });
     await promises_namespaceObject.mkdir(output, { recursive: true });
     const diagnostics = await optimizeMonkeyC(fnMap, Object.keys(buildConfig.barrelMap || {}), config);
-    return Promise.all(Object.entries(fnMap).map(async ([inFile, info]) => {
+    return Promise.all(Object.values(fnMap).map(async (info) => {
         const name = info.output;
         const dir = external_path_.dirname(name);
         await promises_namespaceObject.mkdir(dir, { recursive: true });
         const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(info.ast, info.monkeyCSource);
         await promises_namespaceObject.writeFile(name, opt_source);
-        if (config.checkBuildPragmas) {
-            pragmaChecker(info.ast, diagnostics?.[inFile]);
-        }
         return info.hasTests;
     })).then((results) => {
         const hasTests = results.some((v) => v);