@markw65/monkeyc-optimizer 1.0.45 → 1.1.0

package/build/optimizer.cjs

@@ -4723,8 +4723,6 @@ function mayThrow(node) {
     switch (node.type) {
         case "BinaryExpression":
         case "CallExpression":
-        case "ConditionalExpression":
-        case "LogicalExpression":
         case "NewExpression":
         case "ThrowStatement":
         case "UnaryExpression":
@@ -4869,6 +4867,28 @@ function makeScopedName(dotted, l) {
         throw new Error("Failed to make a ScopedName");
     return result;
 }
+function ast_getLiteralNode(node) {
+    if (node == null)
+        return null;
+    if (node.type == "Literal")
+        return node;
+    if (node.type == "BinaryExpression" && node.operator == "as") {
+        return ast_getLiteralNode(node.left) && node;
+    }
+    if (node.type == "UnaryExpression") {
+        if (node.argument.type != "Literal")
+            return null;
+        switch (node.operator) {
+            case "-": {
+                const [arg, type] = getNodeValue(node.argument);
+                if (type === "Number" || type === "Long") {
+                    return { ...arg, value: -arg.value, raw: `-${arg.raw}` };
+                }
+            }
+        }
+    }
+    return null;
+}
 
 ;// CONCATENATED MODULE: ./src/function-info.ts
 
@@ -5602,31 +5622,9 @@ function unused(state, expression, top) {
     }
     return top ? null : [estmt(expression)];
 }
-function diagnostic(state, loc, message, type = "INFO") {
-    if (!loc || !loc.source)
-        return;
-    const source = loc.source;
-    if (!state.diagnostics)
-        state.diagnostics = {};
-    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.diagnostics, source)) {
-        if (!message)
-            return;
-        state.diagnostics[source] = [];
-    }
-    const diags = state.diagnostics[source];
-    let index = diags.findIndex((item) => item.loc === loc);
-    if (message) {
-        if (index < 0)
-            index = diags.length;
-        diags[index] = { type, loc, message };
-    }
-    else if (index >= 0) {
-        diags.splice(index, 1);
-    }
-}
 function inlineDiagnostic(state, func, call, message) {
     if (inlineRequested(state, func)) {
-        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+        (0,external_api_cjs_namespaceObject.diagnostic)(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
     }
 }
 function inlineWithArgs(state, func, call, context) {
@@ -5651,8 +5649,9 @@ function inlineWithArgs(state, func, call, context) {
         });
         if (retStmtCount > 1) {
             inlineDiagnostic(state, func, call, "Function had more than one return statement");
+            return null;
         }
-        else if ((context.type === "AssignmentExpression" ||
+        if ((context.type === "AssignmentExpression" ||
             context.type === "VariableDeclarator" ||
             context.type === "IfStatement") &&
             retStmtCount !== 1) {
@@ -5684,7 +5683,7 @@ function inlineWithArgs(state, func, call, context) {
     if (!processInlineBody(state, func, call, body, params)) {
         return null;
     }
-    diagnostic(state, call.loc, null);
+    (0,external_api_cjs_namespaceObject.diagnostic)(state, call.loc, null);
     if (context.type !== "ReturnStatement" && retStmtCount) {
         const [last, block] = lastStmt(body);
         if (last.type != "ReturnStatement") {
@@ -5921,7 +5920,6 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 ;// CONCATENATED MODULE: ./src/pragma-checker.ts
 
 
-
 function pragmaChecker(state, ast, diagnostics) {
     const comments = ast.comments;
     if (!comments)
@@ -5963,7 +5961,7 @@ function pragmaChecker(state, ast, diagnostics) {
                     break;
                 }
             }
-            diagnostic(state, comment.loc, `Build pragma '${comment.value}' is invalid`, "ERROR");
+            (0,external_api_cjs_namespaceObject.diagnostic)(state, comment.loc, `Build pragma '${comment.value}' is invalid`, "ERROR");
         }
     };
     const matcher = (quote, needle, haystack) => {
@@ -5987,7 +5985,7 @@ function pragmaChecker(state, ast, diagnostics) {
                 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");
+                    (0,external_api_cjs_namespaceObject.diagnostic)(state, comment.loc, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
                 }
             }
             else if (kind === "expect") {
@@ -6029,7 +6027,7 @@ function pragmaChecker(state, ast, diagnostics) {
                     }
                 }
                 if (!found) {
-                    diagnostic(state, comment.loc, `Missing error message '${needle}`, "ERROR");
+                    (0,external_api_cjs_namespaceObject.diagnostic)(state, comment.loc, `Missing error message '${needle}`, "ERROR");
                 }
             }
             if (matchers.length) {
@@ -6128,6 +6126,7 @@ function buildReducedGraph(state, func, notice) {
         const ret = localState.curBlock;
         state.stack = [...func.stack];
         const stmtStack = [func.node];
+        const testStack = [{ node: func.node }];
         let tryActive = 0;
         state.pre = (node) => {
             if (state.inType || localState.unreachable) {
@@ -6137,6 +6136,10 @@ function buildReducedGraph(state, func, notice) {
                 (isStatement(node) || isExpression(node))) {
                 localState.curBlock.node = node;
             }
+            let topTest = testStack[testStack.length - 1];
+            if (topTest.node !== node && topTest.true) {
+                testStack.push((topTest = { node }));
+            }
             if (isStatement(node)) {
                 stmtStack.push(node);
             }
@@ -6187,9 +6190,15 @@ function buildReducedGraph(state, func, notice) {
                     let head;
                     if (node.type === "WhileStatement") {
                         head = localState.newBlock(top.continue);
+                        const body = {};
+                        testStack.push({
+                            node: node.test,
+                            true: body,
+                            false: top.break,
+                        });
                         state.traverse(node.test);
-                        localState.addEdge(localState.curBlock, top.break);
-                        localState.newBlock();
+                        localState.unreachable = true;
+                        localState.newBlock(body);
                     }
                     else {
                         head = localState.newBlock();
@@ -6197,11 +6206,18 @@ function buildReducedGraph(state, func, notice) {
                     state.traverse(node.body);
                     if (node.type === "DoWhileStatement") {
                         localState.newBlock(top.continue);
+                        testStack.push({
+                            node: node.test,
+                            true: head,
+                            false: top.break,
+                        });
                         state.traverse(node.test);
-                        localState.addEdge(localState.curBlock, top.break);
+                        localState.unreachable = true;
+                    }
+                    else if (!localState.unreachable) {
+                        localState.addEdge(localState.curBlock, head);
                     }
-                    localState.addEdge(localState.curBlock, head);
-                    localState.curBlock = top.break;
+                    localState.newBlock(top.break);
                     return [];
                 }
                 case "TryStatement": {
@@ -6298,9 +6314,15 @@ function buildReducedGraph(state, func, notice) {
                     top.break = {};
                     top.continue = {};
                     if (node.test) {
+                        const body = {};
+                        testStack.push({
+                            node: node.test,
+                            true: body,
+                            false: top.break,
+                        });
                         state.traverse(node.test);
-                        localState.addEdge(localState.curBlock, top.break);
-                        localState.newBlock();
+                        localState.unreachable = true;
+                        localState.newBlock(body);
                     }
                     state.traverse(node.body);
                     localState.newBlock(top.continue);
@@ -6322,39 +6344,91 @@ function buildReducedGraph(state, func, notice) {
                 }
                 case "IfStatement":
                 case "ConditionalExpression": {
-                    state.traverse(node.test);
+                    const consequent = {};
                     const alternate = {};
-                    localState.addEdge(localState.curBlock, alternate);
-                    localState.newBlock();
+                    const next = node.alternate ? {} : alternate;
+                    testStack.push({
+                        node: node.test,
+                        true: consequent,
+                        false: alternate,
+                    });
+                    state.traverse(node.test);
+                    localState.unreachable = true;
+                    if (topTest.true) {
+                        testStack.push({ ...topTest, node: node.consequent });
+                    }
+                    else {
+                        testStack.push({ node: node.consequent, true: next, false: next });
+                    }
+                    localState.newBlock(consequent);
                     state.traverse(node.consequent);
-                    const consequent = localState.unreachable
-                        ? null
-                        : localState.curBlock;
                     localState.unreachable = true;
-                    localState.newBlock(alternate);
                     if (node.alternate) {
-                        state.traverse(node.alternate);
-                        if (!localState.unreachable) {
-                            localState.newBlock();
+                        if (topTest.true) {
+                            testStack.push({ ...topTest, node: node.alternate });
                         }
-                    }
-                    if (consequent) {
-                        if (localState.unreachable) {
-                            localState.newBlock();
+                        else {
+                            testStack.push({ node: node.alternate, true: next, false: next });
                         }
-                        localState.addEdge(consequent, localState.curBlock);
+                        localState.newBlock(alternate);
+                        state.traverse(node.alternate);
+                        localState.unreachable = true;
+                    }
+                    if (next.preds) {
+                        /*
+                         * Given:
+                         * if (cond) {
+                         * } else if (cond2) {
+                         * } // no else
+                         *
+                         * cond2 will cause a branch to the second if's next block
+                         * But if topTest.true, we also need to ensure that next branches
+                         * to both true and false.
+                         *
+                         * So in *this* case, we have to skip the testStack.pop (or manually
+                         * add the edges here).
+                         */
+                        localState.newBlock(next);
+                    }
+                    else if (topTest.node === node) {
+                        testStack.pop();
                     }
                     return [];
                 }
                 case "LogicalExpression": {
+                    const isAnd = node.operator === "&&" || node.operator === "and";
+                    const right = {};
+                    const next = {};
+                    if (isAnd) {
+                        testStack.push({
+                            node: node.left,
+                            true: right,
+                            false: topTest.false || next,
+                        });
+                    }
+                    else {
+                        testStack.push({
+                            node: node.left,
+                            true: topTest.true || next,
+                            false: right,
+                        });
+                    }
                     state.traverse(node.left);
-                    if (localState.unreachable)
-                        break;
-                    const mid = localState.curBlock;
-                    localState.newBlock();
+                    localState.unreachable = true;
+                    localState.newBlock(right);
+                    testStack.push({
+                        node: node.right,
+                        true: topTest.true || next,
+                        false: topTest.false || next,
+                    });
                     state.traverse(node.right);
-                    localState.newBlock();
-                    localState.addEdge(mid, localState.curBlock);
+                    localState.unreachable = true;
+                    if (next.preds) {
+                        localState.newBlock(next);
+                    }
+                    if (topTest.node === node) {
+                        testStack.pop();
+                    }
                     return [];
                 }
                 case "VariableDeclarator":
@@ -6415,6 +6489,7 @@ function buildReducedGraph(state, func, notice) {
         };
         state.post = (node) => {
             const curStmt = stmtStack[stmtStack.length - 1];
+            const topTest = testStack[testStack.length - 1];
             if (!state.inType) {
                 const throws = tryActive > 0 && mayThrow(node);
                 const event = notice(node, curStmt, throws);
@@ -6452,11 +6527,34 @@ function buildReducedGraph(state, func, notice) {
                     addEvent(localState.curBlock, event);
                 }
             }
+            if (localState.top().node === node) {
+                localState.pop();
+            }
+            if (topTest.node === node) {
+                testStack.pop();
+                if (topTest.true && !localState.unreachable) {
+                    localState.addEdge(localState.curBlock, topTest.true);
+                    if (topTest.false !== topTest.true) {
+                        if (localState.curBlock.succs?.length !== 1) {
+                            throw new Error("Internal error: Unexpected successor edges");
+                        }
+                        localState.addEdge(localState.curBlock, topTest.false);
+                        const event = notice(node, curStmt, 1);
+                        if (event) {
+                            event.mayThrow = false;
+                            addEvent(localState.curBlock, event);
+                            localState.unreachable = true;
+                        }
+                    }
+                }
+            }
             if (curStmt === node) {
                 stmtStack.pop();
             }
-            if (localState.top().node === node) {
-                localState.pop();
+            else if (localState.unreachable &&
+                curStmt.type === "BlockStatement" &&
+                isStatement(node)) {
+                return false;
             }
             return null;
         };
@@ -6580,6 +6678,8 @@ function declFullName(decl) {
     if ((0,external_api_cjs_namespaceObject.isStateNode)(decl))
         return decl.fullName;
     switch (decl.type) {
+        case "Identifier":
+            return decl.name;
         case "BinaryExpression":
             return decl.left.name;
         case "EnumStringMember":
@@ -6587,7 +6687,7 @@ function declFullName(decl) {
                 ? `${decl.id.name}:${(0,external_api_cjs_namespaceObject.formatAst)(decl.init)}`
                 : decl.id.name;
         default:
-            throw new Error(`Unexpected EventDecl type: ${decl.type}`);
+            unhandledType(decl);
     }
 }
 function declName(decl) {
@@ -6608,7 +6708,7 @@ function declName(decl) {
             throw new Error(`Unexpected EventDecl type: ${decl.type}`);
     }
 }
-function unhandledExpression(node) {
+function unhandledType(node) {
     throw new Error(`Unhandled expression type: ${node.type}`);
 }
 function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wantsAllRefs) {
@@ -6677,6 +6777,9 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
     return {
         identifiers,
         graph: buildReducedGraph(state, func, (node, stmt, mayThrow) => {
+            if (mayThrow === 1) {
+                return null;
+            }
             const defs = liveStmts.get(node);
             if (defs) {
                 liveStmts.delete(node);
@@ -6820,7 +6923,7 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                 default:
                     if (!isExpression(node))
                         break;
-                    unhandledExpression(node);
+                    unhandledType(node);
             }
             if (mayThrow) {
                 return { type: "exn", node, mayThrow };
@@ -6921,7 +7024,10 @@ function sizeBasedPRE(state, func) {
         }, func.node.body);
         variableDecl.end = variableDecl.start;
         variableDecl.loc.end = variableDecl.loc.start;
-        candidates.forEach((s, decl) => {
+        Array.from(candidates.keys())
+            .map((decl) => [declFullName(decl), decl])
+            .sort()
+            .forEach(([, decl]) => {
             let name;
             let i = 0;
             do {
@@ -6933,6 +7039,7 @@ function sizeBasedPRE(state, func) {
                 i++;
             } while (true);
             declMap.set(decl, name);
+            const s = candidates.get(decl);
             variableDecl.declarations.push(withLoc({
                 type: "VariableDeclarator",
                 id: withLoc({ type: "Identifier", name }, variableDecl),
@@ -6953,7 +7060,71 @@ function sizeBasedPRE(state, func) {
     }
 }
 function buildPREGraph(state, func) {
-    return buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
+    const result = buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
+    // Split blocks that contains refs and defs to the same thing,
+    // to make it easier to pick and choose which refs are converted
+    postOrderTraverse(result.graph, (block) => {
+        if (!block.events) {
+            return;
+        }
+        let modSeen = false;
+        const refs = new Set();
+        const defs = new Set();
+        const splitBlock = (eventIndex) => {
+            const newBlock = { ...block };
+            delete newBlock.node;
+            newBlock.events = block.events?.splice(eventIndex);
+            newBlock.succs?.forEach((succ) => {
+                const i = succ.preds.findIndex((b) => b === block);
+                succ.preds[i] = newBlock;
+                if (succ.expreds?.includes(block)) {
+                    succ.expreds.push(newBlock);
+                }
+            });
+            block.succs = [newBlock];
+            newBlock.preds = [block];
+            delete newBlock.expreds;
+            modSeen = false;
+            refs.clear();
+            defs.clear();
+        };
+        for (let i = block.events.length; i--;) {
+            const event = block.events[i];
+            switch (event.type) {
+                case "ref":
+                    if ((0,external_util_cjs_namespaceObject.some)(event.decl, (decl) => decl.type === "Literal" ||
+                        (decl.type === "VariableDeclarator" &&
+                            decl.node.kind === "const"))) {
+                        break;
+                    }
+                    if (modSeen || defs.has(event.decl)) {
+                        splitBlock(i + 1);
+                    }
+                    refs.add(event.decl);
+                    break;
+                case "def":
+                    if (refs.has(event.decl)) {
+                        splitBlock(i + 1);
+                    }
+                    defs.add(event.decl);
+                    break;
+                case "mod":
+                    if (event.callees &&
+                        (0,external_util_cjs_namespaceObject.every)(event.callees, (callee) => callee.info === false)) {
+                        // calls known to have no side effects can be
+                        // dropped.
+                        block.events.splice(i, 1);
+                        break;
+                    }
+                    if (refs.size) {
+                        splitBlock(i + 1);
+                    }
+                    modSeen = true;
+                    break;
+            }
+        }
+    });
+    return result;
 }
 function anticipatedDecls() {
     return new Map();
@@ -7527,64 +7698,2874 @@ function applyReplacements(func, nodeMap, declMap) {
     });
 }
 
-;// CONCATENATED MODULE: ./src/unused-exprs.ts
+;// CONCATENATED MODULE: ./src/type-flow/union-type.ts
 
 
 
-function cleanupUnusedVars(state, node) {
-    const [parent] = state.stack.slice(-1);
-    if (parent.node !== node) {
+function unionInto(to, from) {
+    if (from.type === 0 || to === from)
+        return false;
+    if (to.type === 0) {
+        to.type = from.type;
+        to.value = from.value;
+        return true;
+    }
+    const newTags = to.type | from.type;
+    if (!(from.type & ~SingleTonTypeTagsConst)) {
+        // - Adding singletons never affects the data.
+        if (newTags === to.type)
+            return false;
+        to.type = newTags;
+        return true;
+    }
+    if (newTags === to.type) {
+        if (to.value === from.value || to.value == null) {
+            return false;
+        }
+        if (from.value == null) {
+            clearValuesUnder(to, from.type);
+            return true;
+        }
+        return mergeMultiple(to, from);
+    }
+    if (to.value != null) {
+        if (from.value == null) {
+            clearValuesUnder(to, from.type);
+            return true;
+        }
+        return mergeMultiple(to, from);
+    }
+    if (from.value == null) {
+        to.type = newTags;
+        return true;
+    }
+    const tmp = cloneType(from);
+    clearValuesUnder(tmp, to.type);
+    to.type = tmp.type;
+    to.value = tmp.value;
+    return true;
+}
+function mergeMultiple(to, from) {
+    const newTags = to.type | from.type;
+    let anyChanged = newTags !== to.type;
+    let mask = 0;
+    const result = {};
+    forEachUnionComponent(to, newTags, (tag, tov) => {
+        const fromv = getUnionComponent(from, tag);
+        if (tov != null) {
+            if (fromv != null) {
+                const [value, changed] = mergeSingle(tag, tov, fromv);
+                if (changed)
+                    anyChanged = true;
+                if (value) {
+                    mask |= tag;
+                    result[tag] = value;
+                }
+            }
+            else if (!(from.type & tag)) {
+                // from doesn't contribute to this tag,
+                // so just keep it. No change.
+                mask |= tag;
+                result[tag] = tov;
+            }
+            else {
+                // We dropped the data for this tag, so
+                // things changed.
+                anyChanged = true;
+            }
+        }
+        else if (fromv && !(to.type & tag)) {
+            // to doesn't contribute to this tag,
+            // so just keep from's component.
+            // this is new, so it changed.
+            anyChanged = true;
+            mask |= tag;
+            result[tag] = fromv;
+        }
+    });
+    if (!anyChanged)
+        return false;
+    to.type = newTags;
+    if (!mask) {
+        delete to.value;
+        return true;
+    }
+    if (hasUnionData(newTags)) {
+        to.value = result;
+        to.value.mask = mask;
+        return true;
+    }
+    if (mask & (mask - 1)) {
+        throw new Error("Union incorrectly produced a UnionData");
+    }
+    to.value = result[mask];
+    return true;
+}
+function tryUnion(to, from) {
+    to = cloneType(to);
+    if (unionInto(to, from))
+        return to;
+    return null;
+}
+function mergeSingle(type, to, from) {
+    switch (type) {
+        case TypeTag.Number:
+        case TypeTag.Long:
+        case TypeTag.Float:
+        case TypeTag.Double:
+        case TypeTag.Char:
+        case TypeTag.String:
+        case TypeTag.Symbol:
+            if (to === from) {
+                return [to, false];
+            }
+            return [null, true];
+        case TypeTag.Array: {
+            const merged = tryUnion(to, from);
+            return [merged || to, merged != null];
+        }
+        case TypeTag.Dictionary: {
+            const { key, value } = to;
+            const keyChange = tryUnion(key, from.key);
+            const valueChange = tryUnion(value, from.value);
+            if (keyChange || valueChange) {
+                return [{ key: keyChange || key, value: valueChange || value }, true];
+            }
+            return [to, false];
+        }
+        case TypeTag.Module:
+        case TypeTag.Function:
+        case TypeTag.Class:
+        case TypeTag.Typedef:
+            return mergeStateDecls(to, from);
+        case TypeTag.Object: {
+            const klass = to.klass;
+            const [obj, objChanged] = mergeObjectValues(to.obj, from.obj);
+            const klassChanged = tryUnion(klass, from.klass);
+            if (klassChanged || objChanged) {
+                if (obj) {
+                    return [{ klass: klassChanged, obj }, true];
+                }
+                return [{ klass: klassChanged }, true];
+            }
+            return [to, false];
+        }
+        case TypeTag.Enum: {
+            const toE = to;
+            const fromE = from;
+            if (toE.enum !== fromE.enum) {
+                return [null, true];
+            }
+            if (!toE.value) {
+                return [toE, false];
+            }
+            if (!fromE.value) {
+                delete toE.value;
+                return [toE, true];
+            }
+            const toValue = tryUnion(toE.value, fromE.value);
+            if (toValue) {
+                return [{ enum: toE.enum, value: toValue }, true];
+            }
+            return [toE, false];
+        }
+    }
+    throw new Error(`Unexpected type ${type}`);
+}
+function mergeObjectValues(to, from) {
+    if (!to) {
+        return [to, false];
+    }
+    if (!from) {
+        return [from, true];
+    }
+    let empty = true;
+    let result = to;
+    Object.entries(to).forEach(([key, value]) => {
+        if (!hasProperty(from, key)) {
+            if (result === to)
+                result = { ...result };
+            delete result[key];
+            return;
+        }
+        const rep = cloneType(value);
+        if (unionInto(rep, from[key])) {
+            if (result === to)
+                result = { ...result };
+            result[key] = rep;
+        }
+        empty = false;
+    });
+    if (empty) {
+        return [undefined, true];
+    }
+    return [result, result !== to];
+}
+function mergeStateDecls(to, from) {
+    let changed = false;
+    let result = to;
+    (0,external_util_cjs_namespaceObject.forEach)(from, (v) => {
+        if ((0,external_util_cjs_namespaceObject.some)(to, (t) => t === v)) {
+            return;
+        }
+        if (Array.isArray(result)) {
+            if (result === to) {
+                result = [...result, v];
+            }
+            else {
+                result.push(v);
+            }
+        }
+        else {
+            result = [to, v];
+        }
+        changed = true;
+    });
+    return [result, changed];
+}
+// precondition: hasUnionData
+function nonUnionDataMask(tag) {
+    if (tag & (tag - 1)) {
+        // More than one bit set, but it doesn't have
+        // UnionData, so it must either have a single bit
+        // under UnionDataTypeTagsConst, or a single bit
+        // under ValueTypeTagsConst.
+        return tag & UnionDataTypeTagsConst || tag & ValueTypeTagsConst;
+    }
+    return tag;
+}
+/*
+ * Remove any data associated with tag.
+ * Add (or remove) tag to (or from) v.type, according
+ * to clearTag.
+ */
+function clearValuesUnder(v, tag, clearTag = false) {
+    const newTag = clearTag ? v.type & ~tag : v.type | tag;
+    // If the incoming type consists of singletons,
+    // we can always merge it without affecting our data.
+    tag &= ~SingleTonTypeTagsConst;
+    if (!tag) {
+        v.type = newTag;
         return;
     }
-    if (parent.type != "BlockStatement") {
-        throw new Error(`Unexpected parent type '${parent.type}' for local declaration`);
+    // We only keep data for ValueTypeTags if there is
+    // only one of them. If the type being merged has
+    // no data for one of them, the resulting type has
+    // no data for any of them.
+    if (tag & ValueTypeTagsConst) {
+        tag |= ValueTypeTagsConst;
+    }
+    if (!hasUnionData(v.type)) {
+        // get the single bit corresponding to v's data
+        const dataMask = nonUnionDataMask(v.type);
+        if (dataMask & tag) {
+            // the merging type has no data for our
+            // exact type; so delete all our data.
+            // eg Number<1> or String => Number or String
+            v.type = newTag;
+            delete v.value;
+            return;
+        }
+        if (dataMask & ValueTypeTagsConst) {
+            // assert(tag & UnionDataTypeTags)
+            // v had data corresponding to one of the
+            // ValueTypeTags. But tag adds at least
+            // one new bit. So drop the data.
+            // eg Number<1> or Array => Number or Array
+            delete v.value;
+            v.type = newTag;
+            return;
+        }
+        if (hasUnionData(newTag)) {
+            // v had data corresponding to one of the
+            // UnionDataTypeTags, and tag adds at least
+            // one new bit. Keep the data, but move it into
+            // a UnionData.
+            // eg Array<Number> or Dictionary remains as is.
+            const mask = v.type & UnionDataTypeTagsConst;
+            v.value = {
+                [mask]: v.value,
+                mask,
+            };
+        }
+        v.type = newTag;
+        return;
     }
-    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];
+    v.type = newTag;
+    const unionData = v.value;
+    let remain = unionData.mask & ~tag;
+    if (!remain) {
+        delete v.value;
+        return;
+    }
+    const newData = { mask: remain };
+    while (remain) {
+        const next = remain & (remain - 1);
+        const bit = (remain - next);
+        newData[bit] = unionData[bit];
+        remain = next;
+    }
+    if (!hasUnionData(newTag)) {
+        v.value = newData[(newTag & UnionDataTypeTagsConst)];
+    }
+    else {
+        v.value = newData;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/type-flow/types.ts
+
+
+
+
+
+
+/**
+ * TypeBit gives the position of the 1 bit in TypeTag
+ */
+var TypeBit;
+(function (TypeBit) {
+    TypeBit[TypeBit["Null"] = 0] = "Null";
+    TypeBit[TypeBit["False"] = 1] = "False";
+    TypeBit[TypeBit["True"] = 2] = "True";
+    TypeBit[TypeBit["Number"] = 3] = "Number";
+    TypeBit[TypeBit["Long"] = 4] = "Long";
+    TypeBit[TypeBit["Float"] = 5] = "Float";
+    TypeBit[TypeBit["Double"] = 6] = "Double";
+    TypeBit[TypeBit["Char"] = 7] = "Char";
+    TypeBit[TypeBit["String"] = 8] = "String";
+    TypeBit[TypeBit["Array"] = 9] = "Array";
+    TypeBit[TypeBit["Dictionary"] = 10] = "Dictionary";
+    TypeBit[TypeBit["Module"] = 11] = "Module";
+    TypeBit[TypeBit["Function"] = 12] = "Function";
+    TypeBit[TypeBit["Class"] = 13] = "Class";
+    TypeBit[TypeBit["Object"] = 14] = "Object";
+    TypeBit[TypeBit["Enum"] = 15] = "Enum";
+    TypeBit[TypeBit["Symbol"] = 16] = "Symbol";
+    TypeBit[TypeBit["Typedef"] = 17] = "Typedef";
+})(TypeBit || (TypeBit = {}));
+var TypeTag;
+(function (TypeTag) {
+    TypeTag[TypeTag["Never"] = 0] = "Never";
+    TypeTag[TypeTag["Null"] = 1] = "Null";
+    TypeTag[TypeTag["False"] = 2] = "False";
+    TypeTag[TypeTag["True"] = 4] = "True";
+    TypeTag[TypeTag["Boolean"] = 6] = "Boolean";
+    TypeTag[TypeTag["Number"] = 8] = "Number";
+    TypeTag[TypeTag["Long"] = 16] = "Long";
+    TypeTag[TypeTag["Float"] = 32] = "Float";
+    TypeTag[TypeTag["Double"] = 64] = "Double";
+    TypeTag[TypeTag["Numeric"] = 120] = "Numeric";
+    TypeTag[TypeTag["Char"] = 128] = "Char";
+    TypeTag[TypeTag["String"] = 256] = "String";
+    TypeTag[TypeTag["Array"] = 512] = "Array";
+    TypeTag[TypeTag["Dictionary"] = 1024] = "Dictionary";
+    TypeTag[TypeTag["Module"] = 2048] = "Module";
+    TypeTag[TypeTag["Function"] = 4096] = "Function";
+    TypeTag[TypeTag["Class"] = 8192] = "Class";
+    TypeTag[TypeTag["Object"] = 16384] = "Object";
+    TypeTag[TypeTag["Enum"] = 32768] = "Enum";
+    TypeTag[TypeTag["Symbol"] = 65536] = "Symbol";
+    TypeTag[TypeTag["Typedef"] = 131072] = "Typedef";
+    TypeTag[TypeTag["Any"] = 262143] = "Any";
+})(TypeTag || (TypeTag = {}));
+const SingleTonTypeTagsConst = TypeTag.Null | TypeTag.False | TypeTag.True;
+const UnionDataTypeTagsConst = TypeTag.Array |
+    TypeTag.Dictionary |
+    TypeTag.Module |
+    TypeTag.Function |
+    TypeTag.Class |
+    TypeTag.Object |
+    TypeTag.Enum |
+    TypeTag.Typedef;
+const ValueTypeTagsConst = TypeTag.Number |
+    TypeTag.Long |
+    TypeTag.Float |
+    TypeTag.Double |
+    TypeTag.Char |
+    TypeTag.String |
+    TypeTag.Symbol;
+const ObjectLikeTagsConst = TypeTag.Boolean |
+    ValueTypeTagsConst |
+    TypeTag.Array |
+    TypeTag.Dictionary |
+    TypeTag.Enum;
+function isExact(v) {
+    // check that there is exactly one bit set
+    return v.type !== 0 && !(v.type & (v.type - 1));
+}
+function isUnion(v) {
+    return v.type !== 0 && !isExact(v);
+}
+function isSingleton(v) {
+    return isExact(v) && (v.type & SingleTonTypeTagsConst) !== 0;
+}
+function hasValue(v) {
+    return (isExact(v) &&
+        ((v.type & SingleTonTypeTagsConst) !== 0 || v.value !== undefined));
+}
+function lookupByFullName(state, fullName) {
+    return fullName.split(".").reduce((results, part) => {
+        return results
+            .flatMap((result) => (0,external_api_cjs_namespaceObject.isStateNode)(result)
+            ? result.decls?.[part] || result.type_decls?.[part]
+            : null)
+            .filter((sn) => !!sn);
+    }, [state.stack[0]]);
+}
+function getMethod(state) {
+    const results = lookupByFullName(state, "Toybox.Lang.Method");
+    if (results.length !== 1) {
+        throw new Error("Internal error: Didn't find Toybox.Lang.Method");
+    }
+    if (results[0].type !== "ClassDeclaration") {
+        throw new Error("Internal error: Toybox.Lang.Method was not a Class");
+    }
+    return results[0];
+}
+function cloneType(t) {
+    return { ...t };
+}
+function typeFromTypeStateNode(state, sn, classVsObj) {
+    switch (sn.type) {
+        case "ClassDeclaration": {
+            switch (sn.fullName) {
+                case "$.Toybox.Lang.Boolean":
+                    return { type: TypeTag.Boolean };
+                case "$.Toybox.Lang.Number":
+                    return { type: TypeTag.Number };
+                case "$.Toybox.Lang.Long":
+                    return { type: TypeTag.Long };
+                case "$.Toybox.Lang.Float":
+                    return { type: TypeTag.Float };
+                case "$.Toybox.Lang.Double":
+                    return { type: TypeTag.Double };
+                case "$.Toybox.Lang.Char":
+                    return { type: TypeTag.Char };
+                case "$.Toybox.Lang.String":
+                    return { type: TypeTag.String };
+                case "$.Toybox.Lang.Array":
+                    return { type: TypeTag.Array };
+                case "$.Toybox.Lang.Dictionary":
+                    return { type: TypeTag.Dictionary };
+                case "$.Toybox.Lang.Symbol":
+                    return { type: TypeTag.Symbol };
+                case "$.Toybox.Lang.Object":
+                    return { type: TypeTag.Object };
+            }
+            const cls = { type: TypeTag.Class, value: sn };
+            if (classVsObj)
+                return cls;
+            return { type: TypeTag.Object, value: { klass: cls } };
+        }
+        case "FunctionDeclaration":
+            return { type: TypeTag.Function, value: sn };
+        case "ModuleDeclaration":
+            return { type: TypeTag.Module, value: sn };
+        case "Program":
+            return { type: TypeTag.Module };
+        case "EnumDeclaration":
+            return { type: TypeTag.Enum, value: { enum: sn } };
+        case "EnumStringMember": {
+            const e = state.enumMap?.get(sn);
+            const value = sn.init?.type === "Literal"
+                ? typeFromLiteral(sn.init)
+                : { type: TypeTag.Numeric | TypeTag.String };
+            if (e) {
+                return { type: TypeTag.Enum, value: { enum: e, value } };
+            }
+            return value;
+        }
+        case "TypedefDeclaration": {
+            if (sn.resolvedType) {
+                return sn.resolvedType;
+            }
+            if (sn.isExpanding) {
+                sn.isRecursive = true;
+                return { type: TypeTag.Typedef, value: sn };
+            }
+            sn.isExpanding = true;
+            const result = typeFromTypespec(state, sn.node.ts.argument, sn.stack);
+            delete sn.isExpanding;
+            if (sn.isRecursive) {
+                // Something like
+                //   typedef Foo as Number or String or Foo;
+                // is pointless. Its just the same as
+                //   typedef Foo as Number or String;
+                // Recursive typedefs are only useful when the
+                // recursion happens under a generic.
+                // So check for that, and remove it.
+                if (result.type & TypeTag.Typedef) {
+                    const value = getUnionComponent(result, TypeTag.Typedef);
+                    if (value) {
+                        const a = [];
+                        (0,external_util_cjs_namespaceObject.forEach)(value, (v) => {
+                            if (v !== sn)
+                                a.push(v);
+                        });
+                        clearValuesUnder(result, TypeTag.Typedef, true);
+                        if (a.length) {
+                            unionInto(result, {
+                                type: TypeTag.Typedef,
+                                value: a.length > 1 ? a : a[0],
+                            });
+                        }
+                    }
+                }
             }
-        });
-        if (toRemove) {
-            const varDeclarations = new Map();
-            const stack = [];
-            traverseAst(node, (node) => {
-                switch (node.type) {
-                    case "SwitchCase":
-                        stack.push(node.consequent);
-                        break;
-                    case "BlockStatement":
-                        stack.push(node.body);
-                        break;
+            sn.resolvedType = result;
+            return result;
+        }
+        case "VariableDeclarator":
+            if (sn.node.kind === "const" && sn.node.init) {
+                if (sn.node.init.type === "Literal") {
+                    return typeFromLiteral(sn.node.init);
                 }
-            }, (node) => {
-                switch (node.type) {
-                    case "SwitchCase":
-                    case "BlockStatement":
-                        stack.pop();
-                        break;
-                    case "VariableDeclaration": {
-                        node.declarations.forEach((decl, i) => {
-                            const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(decl.id);
-                            if (hasProperty(toRemove, name)) {
-                                const info = varDeclarations.get(node);
-                                if (info) {
-                                    info.indices.push(i);
-                                }
-                                else {
-                                    varDeclarations.set(node, {
-                                        parent: stack[stack.length - 1],
-                                        indices: [i],
-                                    });
-                                }
-                            }
-                        });
-                        break;
+                const [value] = getNodeValue(sn.node.init);
+                if (value) {
+                    return evaluateExpr(state, sn.node.init).value;
+                }
+            }
+            if (sn.node.id.type === "BinaryExpression") {
+                return typeFromTypespec(state, sn.node.id.right, sn.stack);
+            }
+            return { type: TypeTag.Any };
+    }
+    throw new Error(`Internal error: Unexpected StateNodeDecl.type: ${sn.type}`);
+}
+function typeFromTypeStateNodes(state, sns, classVsObj) {
+    return sns.reduce((cur, sn) => {
+        unionInto(cur, typeFromTypeStateNode(state, sn, classVsObj));
+        return cur;
+    }, { type: TypeTag.Never });
+}
+function typeFromSingleTypeSpec(state, type, stack) {
+    if (typeof type === "string") {
+        type = { type: "TypeSpecPart", name: type };
+    }
+    switch (type.type) {
+        case "ObjectExpression":
+            return { type: TypeTag.Dictionary };
+        case "TypeSpecPart": {
+            if (type.body) {
+                // this is an interface declaration.
+                // For now, make it an instance of an unknown class.
+                return { type: TypeTag.Object };
+            }
+            if (type.callspec) {
+                // only legal thing here is Method(<args>) as <result>
+                // For now, make it an instance of an unknown class.
+                return {
+                    type: TypeTag.Object,
+                    value: { klass: { type: TypeTag.Class, value: getMethod(state) } },
+                };
+            }
+            const id = typeof type.name === "string" ? makeScopedName(type.name) : type.name;
+            const [, results] = state.lookupType(id, null, stack);
+            if (!results) {
+                if (id.type === "Identifier") {
+                    switch (id.name) {
+                        case "Void":
+                        case "Null":
+                            return { type: TypeTag.Null };
+                    }
+                }
+                const level = state.config?.checkInvalidSymbols;
+                if (level !== "OFF") {
+                    (0,external_api_cjs_namespaceObject.diagnostic)(state, id.loc, `Unable to resolve type ${(0,external_api_cjs_namespaceObject.formatAst)(id)}`, level || "WARNING");
+                }
+                return { type: TypeTag.Any };
+            }
+            const resultType = results.reduce((cur, lookupDefn) => {
+                unionInto(cur, typeFromTypeStateNodes(state, lookupDefn.results));
+                return cur;
+            }, { type: TypeTag.Never });
+            if (type.generics) {
+                if (resultType.type === TypeTag.Array && type.generics.length === 1) {
+                    resultType.value = typeFromTypespec(state, type.generics[0], stack);
+                }
+                else if (resultType.type === TypeTag.Dictionary &&
+                    type.generics.length === 2) {
+                    resultType.value = {
+                        key: typeFromTypespec(state, type.generics[0], stack),
+                        value: typeFromTypespec(state, type.generics[1], stack),
+                    };
+                }
+            }
+            return resultType;
+        }
+    }
+}
+function typeFromTypespec(state, ts, stack) {
+    if (!state.config?.trustDeclaredTypes) {
+        if (ts.ts.length === 1 && typeof ts.ts[0] === "string") {
+            const e = lookupByFullName(state, ts.ts[0]);
+            if (e && e.length === 1 && e[0].type === "EnumDeclaration") {
+                return {
+                    type: TypeTag.Enum,
+                    value: { enum: e[0] },
+                };
+            }
+        }
+        return { type: TypeTag.Any };
+    }
+    return ts.ts.reduce((cur, type) => {
+        unionInto(cur, typeFromSingleTypeSpec(state, type, stack));
+        return cur;
+    }, { type: TypeTag.Never });
+}
+function typeFromLiteral(literal) {
+    const [value, type] = getNodeValue(literal);
+    switch (type) {
+        case "Null":
+            return { type: TypeTag.Null };
+        case "Boolean":
+            return literal.value ? { type: TypeTag.True } : { type: TypeTag.False };
+        case "Number":
+            return { type: TypeTag.Number, value: value.value };
+        case "Long":
+            return { type: TypeTag.Long, value: BigInt(value.value) };
+        case "Float":
+            return { type: TypeTag.Float, value: value.value };
+        case "Double":
+            return { type: TypeTag.Double, value: value.value };
+        case "Char":
+            return { type: TypeTag.Char, value: value.value };
+        case "String":
+            return { type: TypeTag.String, value: value.value };
+        default:
+            throw new Error(`Unexpected literal type: ${type}:${literal.value}`);
+    }
+}
+function mcExprFromType(type) {
+    switch (type.type) {
+        case TypeTag.Null:
+            return { type: "Literal", value: null, raw: "null" };
+        case TypeTag.False:
+            return { type: "Literal", value: false, raw: "false" };
+        case TypeTag.True:
+            return { type: "Literal", value: true, raw: "true" };
+        case TypeTag.Number:
+            return { type: "Literal", value: type.value, raw: `${type.value}` };
+        case TypeTag.Long:
+            return { type: "Literal", value: type.value, raw: `${type.value}l` };
+        case TypeTag.Float: {
+            let raw = type.value.toString();
+            if (prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
+                raw += "f";
+            }
+            else {
+                const match = raw.match(/^(-)?(\d*)\.(\d+)(e\d+)?/);
+                if (match && match[2].length + match[3].length > 9) {
+                    for (let l = 9 - match[2].length; l > 0; l--) {
+                        const s = `${match[1] || ""}${match[2]}.${match[3].substring(0, l)}${match[4] || ""}`;
+                        if (type.value !== roundToFloat(parseFloat(s)))
+                            break;
+                        raw = s;
+                    }
+                }
+            }
+            return { type: "Literal", value: type.value, raw };
+        }
+        case TypeTag.Double:
+            return { type: "Literal", value: type.value, raw: `${type.value}d` };
+        case TypeTag.Char:
+            return {
+                type: "Literal",
+                value: type.value,
+                raw: `'${JSON.stringify(type.value).slice(1, -1)}'`,
+            };
+        case TypeTag.String:
+            return {
+                type: "Literal",
+                value: type.value,
+                raw: JSON.stringify(type.value),
+            };
+        case TypeTag.Enum:
+            if (type.value.value && hasValue(type.value.value)) {
+                const left = mcExprFromType(type.value.value);
+                if (left) {
+                    return {
+                        type: "BinaryExpression",
+                        operator: "as",
+                        left,
+                        right: {
+                            type: "TypeSpecList",
+                            ts: [type.value.enum.fullName.slice(2)],
+                        },
+                    };
+                }
+            }
+    }
+    return null;
+}
+/*
+ * Cast one type to another, as might happen during
+ * operator coercion. If the source type has a value,
+ * try to preserve it.
+ * eg in 1.0 + 2, the 2 will be converted to 2.0 before adding.
+ * Note that many possible conversions simply can't happen.
+ * eg Number can be converted to Long, Float or Double, but
+ * Long, Float and Double never get converted to Number.
+ */
+function castType(type, target) {
+    if (type.type === target)
+        return cloneType(type);
+    const result = { type: target };
+    if (hasValue(type)) {
+        if (isExact(result)) {
+            switch (result.type) {
+                case TypeTag.Null:
+                case TypeTag.False:
+                case TypeTag.True:
+                case TypeTag.Number:
+                    break;
+                case TypeTag.Long:
+                    if (type.type === TypeTag.Number) {
+                        result.value = BigInt(type.value);
+                        return result;
+                    }
+                    break;
+                case TypeTag.Float:
+                    if (type.type === TypeTag.Number) {
+                        result.value = type.value;
+                        return result;
+                    }
+                    break;
+                case TypeTag.Double:
+                    switch (type.type) {
+                        case TypeTag.Number:
+                        case TypeTag.Long:
+                        case TypeTag.Float:
+                            result.value = Number(type.value);
+                            return result;
+                    }
+                    break;
+                case TypeTag.Char:
+                    switch (type.type) {
+                        case TypeTag.Number:
+                        case TypeTag.Long:
+                            result.value = String.fromCharCode(Number(type.value));
+                            return result;
+                    }
+                    break;
+                case TypeTag.String:
+                    switch (type.type) {
+                        case TypeTag.Null:
+                            result.value = "null";
+                            return result;
+                        case TypeTag.False:
+                            result.value = "false";
+                            return result;
+                        case TypeTag.True:
+                            result.value = "true";
+                            return result;
+                        case TypeTag.Number:
+                        case TypeTag.Long:
+                            result.value = type.value.toString();
+                            return result;
+                        case TypeTag.Float:
+                        case TypeTag.Double:
+                            // Dont try to implement these, due to inconsistencies and bugs
+                            return result;
+                        case TypeTag.Char:
+                            result.value = type.value;
+                            return result;
+                        default:
+                            return result;
+                    }
+                    break;
+            }
+            throw new Error(`Trying to cast ${display(type)} to ${display(result)}`);
+        }
+        else if (result.type === TypeTag.Boolean) {
+            // Number or Long operands to '&', '|', and '^' are coerced
+            // to boolean if the other argument is boolean.
+            if (type.type & (TypeTag.Number | TypeTag.Long)) {
+                result.type = type.value == 0 ? TypeTag.False : TypeTag.True;
+                return result;
+            }
+        }
+    }
+    return result;
+}
+/*
+ * Anything consisting of solely these types is definitely true
+ */
+const TruthyTypes = TypeTag.True |
+    TypeTag.Object |
+    TypeTag.Module |
+    TypeTag.Class |
+    TypeTag.Function;
+function mustBeTrue(arg) {
+    return (((arg.type === TypeTag.Number || arg.type === TypeTag.Long) &&
+        arg.value != null &&
+        arg.value != 0) ||
+        ((arg.type & TruthyTypes) != 0 && (arg.type & ~TruthyTypes) == 0));
+}
+function mustBeFalse(arg) {
+    return (arg.type === TypeTag.Null ||
+        arg.type === TypeTag.False ||
+        ((arg.type === TypeTag.Number || arg.type === TypeTag.Long) &&
+            arg.value != null &&
+            arg.value == 0));
+}
+function display(type) {
+    const names = (v, fn) => (0,external_util_cjs_namespaceObject.map)(v, fn)
+        .sort()
+        .filter((s, i, arr) => !i || s !== arr[i - 1])
+        .join(" or ");
+    const parts = [];
+    const displayOne = (bit, value) => {
+        switch (bit) {
+            case TypeTag.Null:
+            case TypeTag.False:
+            case TypeTag.True:
+                throw new Error("Unexpected value for SingletonTypeTag");
+            case TypeTag.Number:
+            case TypeTag.Long:
+            case TypeTag.Float:
+            case TypeTag.Double:
+                return value.toString();
+            case TypeTag.Char:
+                return `'${JSON.stringify(value).slice(1, -1)}'`;
+            case TypeTag.String:
+                return JSON.stringify(type.value);
+            case TypeTag.Array:
+                return display(value);
+            case TypeTag.Dictionary:
+                return `${display(value.key)}, ${display(value.value)}`;
+            case TypeTag.Module:
+            case TypeTag.Function:
+            case TypeTag.Class:
+            case TypeTag.Typedef:
+                return names(value, (v) => v.fullName.slice(2));
+            case TypeTag.Object: {
+                const klass = value.klass;
+                if (!klass.value)
+                    return undefined;
+                const obj = value.obj;
+                const ret = displayOne(TypeTag.Class, klass.value);
+                return obj
+                    ? `${ret}<{${Object.entries(obj)
+                        .map(([key, value]) => `${key}: ${display(value)}`)
+                        .join(", ")}}>`
+                    : ret;
+            }
+            case TypeTag.Enum: {
+                const v = value;
+                return v.value
+                    ? `${display(v.value)} as ${v.enum.fullName.slice(2)}`
+                    : v.enum.fullName.slice(2);
+            }
+            case TypeTag.Symbol:
+                return `:${value}`;
+            default:
+                throw new Error(`Unexpected type tag '${bit}'`);
+        }
+    };
+    let bits = type.type;
+    if (!bits)
+        return "Never";
+    if (bits === TypeTag.Any && type.value == null) {
+        return "Any";
+    }
+    while (bits) {
+        const next = bits & (bits - 1);
+        const bit = bits - next;
+        if (bit === TypeTag.False && next & TypeTag.True) {
+            parts.push("Boolean");
+            bits = next - TypeTag.True;
+            continue;
+        }
+        const name = TypeTag[bit];
+        const value = getUnionComponent(type, bit);
+        const valueStr = value != null && displayOne(bit, value);
+        if (!valueStr) {
+            parts.push(name);
+        }
+        else if (bit &
+            (TypeTag.Object |
+                TypeTag.Enum |
+                TypeTag.Typedef |
+                TypeTag.Symbol |
+                TypeTag.String)) {
+            parts.push(valueStr);
+        }
+        else {
+            parts.push(`${name}<${valueStr}${valueStr.endsWith(">") ? " " : ""}>`);
+        }
+        bits = next;
+    }
+    return parts.join(" or ");
+}
+function hasUnionData(tag) {
+    tag &= UnionDataTypeTagsConst;
+    return (tag & (tag - 1)) != 0;
+}
+function getObjectValue(t) {
+    if (!(t.type & TypeTag.Object) || t.value == null)
+        return null;
+    if (hasUnionData(t.type)) {
+        return t.value[TypeTag.Object];
+    }
+    return t.value;
+}
+function forEachUnionComponent(v, bits, fn) {
+    // never iterate the singleton bits, because they don't have data
+    bits &= ~SingleTonTypeTagsConst;
+    if (!bits)
+        return;
+    if (v.type & UnionDataTypeTagsConst) {
+        // Don't iterate the value type bits if any union bit is set
+        bits &= ~ValueTypeTagsConst;
+    }
+    else if (bits & (bits - 1)) {
+        // More than one ValueTypeTagsConst bit set, so there's
+        // no data.
+        return;
+    }
+    const hasUnion = hasUnionData(v.type);
+    const unionData = v.value;
+    do {
+        const next = bits & (bits - 1);
+        const bit = bits - next;
+        const data = hasUnion
+            ? unionData[bit]
+            : bit & v.type
+                ? v.value
+                : null;
+        if (fn(bit, data) === false)
+            break;
+        bits = next;
+    } while (bits);
+}
+function getUnionComponent(v, tag) {
+    if (v.value == null)
+        return null;
+    let bits = v.type & ~SingleTonTypeTagsConst;
+    if (!bits)
+        return null;
+    if (bits & (bits - 1)) {
+        bits &= UnionDataTypeTagsConst;
+        if (!bits) {
+            throw new Error(`Non-exact type had no union bits set`);
+        }
+    }
+    if (bits === tag) {
+        return v.value;
+    }
+    else if (bits & tag) {
+        const unionData = v.value;
+        return unionData[tag] || null;
+    }
+    return null;
+}
+
+;// CONCATENATED MODULE: ./src/type-flow/interp-binary.ts
+
+
+
+/*
+ * Compute the possible type tags of the result of an arithmetic
+ * operation on left and right.
+ *
+ * allowed gives the set of allowed input types.
+ *
+ *   + => Number | Long | Float | Double | String | Char | Null
+ *   - => Number | Long | Float | Double
+ */
+function common_types(left, right, allowed) {
+    const types = left.type | right.type;
+    let mask = TypeTag.True |
+        TypeTag.False |
+        TypeTag.Number |
+        TypeTag.Long |
+        TypeTag.Float |
+        TypeTag.Double;
+    if (types & allowed & TypeTag.String) {
+        mask |=
+            TypeTag.String |
+                TypeTag.Char |
+                TypeTag.Null |
+                TypeTag.Dictionary |
+                TypeTag.Array;
+    }
+    else if (types & allowed & TypeTag.Char) {
+        mask |= TypeTag.Char;
+    }
+    mask &= allowed;
+    const lt = left.type & mask;
+    const rt = right.type & mask;
+    let result = lt & TypeTag.String;
+    if (lt & TypeTag.Null)
+        result |= rt & TypeTag.String;
+    if (lt & TypeTag.Boolean) {
+        result |=
+            (rt & TypeTag.Boolean) | TypeTag.Number | TypeTag.Long && TypeTag.Boolean;
+    }
+    if (lt & TypeTag.Number) {
+        result |=
+            rt & TypeTag.Boolean ? TypeTag.Boolean : rt & ~SingleTonTypeTagsConst;
+    }
+    if (lt & TypeTag.Long) {
+        if (rt & TypeTag.Boolean) {
+            result |= TypeTag.Boolean;
+        }
+        else {
+            if (rt & (TypeTag.Number | TypeTag.Long))
+                result |= TypeTag.Long;
+            if (rt & (TypeTag.Float | TypeTag.Double))
+                result |= TypeTag.Double;
+            result |= rt & (TypeTag.String | TypeTag.Char);
+        }
+    }
+    if (lt & TypeTag.Float) {
+        if (rt & (TypeTag.Number | TypeTag.Float))
+            result |= TypeTag.Float;
+        if (rt & (TypeTag.Long | TypeTag.Double))
+            result |= TypeTag.Double;
+        result |= rt & TypeTag.String;
+    }
+    if (lt & TypeTag.Double) {
+        if (rt & (TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double)) {
+            result |= TypeTag.Double;
+        }
+        result |= rt & TypeTag.String;
+    }
+    if (lt & TypeTag.Char) {
+        if (rt & (TypeTag.Number | TypeTag.Long)) {
+            result |= TypeTag.Char;
+        }
+        if (rt & (TypeTag.Char | TypeTag.String)) {
+            result |= TypeTag.String;
+        }
+    }
+    return {
+        tag: result,
+        castArgs: !(result & TypeTag.Char) ? result : false,
+    };
+}
+function compare_types(left, right) {
+    const ret = common_types(left, right, TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double);
+    return { tag: TypeTag.Boolean, castArgs: ret.castArgs };
+}
+function equalsCheck(left, right) {
+    // compare numbers for equality without regard for type;
+    // otherwise if its Number vs Char, compare the char-code with the number;
+    // otherwise if its Number vs Boolean, 1/0 compare equal to true/false
+    // otherwise if the types are different, the result is
+    //   - unknown if its Object vs any normal type (because eg Number is also Object)
+    //   - currently unknown if its Object vs Null (because we can't trust api.mir to
+    //     always include Null in the possible return types)
+    // otherwise if its a singleton type (Null, True, False)
+    //   the result is true;
+    // otherwise if its a Char or Symbol, compare for equality
+    // otherwise its unknown (we don't track object identity).
+    // Note that each type can only have a single bit set. This is important!
+    return left.type & TypeTag.Numeric && right.type & TypeTag.Numeric
+        ? left.value == right.value
+        : (left.type | right.type) == (TypeTag.Number | TypeTag.Char)
+            ? // Char vs Number is true iff the number is the char-code of the char
+                left.type === TypeTag.Char
+                    ? left.value.charCodeAt(0) === right.value
+                    : left.value === right.value.charCodeAt(0)
+            : left.type == TypeTag.Number && right.type & TypeTag.Boolean
+                ? left.value == (right.value ? 1 : 0)
+                : right.type == TypeTag.Number && left.type & TypeTag.Boolean
+                    ? right.value == (left.value ? 1 : 0)
+                    : left.type !== right.type
+                        ? ((left.type | right.type) &
+                            (TypeTag.Object |
+                                TypeTag.Module |
+                                TypeTag.Function |
+                                TypeTag.Class)) ===
+                            TypeTag.Object
+                            ? undefined
+                            : false
+                        : left.type === TypeTag.Char || left.type === TypeTag.Symbol
+                            ? left.value === right.value
+                            : isSingleton(left)
+                                ? true
+                                : undefined;
+}
+let operators = null;
+function evaluateBinaryTypes(op, left, right) {
+    if (!operators) {
+        operators = {
+            "+": {
+                allowed: TypeTag.Number |
+                    TypeTag.Long |
+                    TypeTag.Float |
+                    TypeTag.Double |
+                    TypeTag.String |
+                    TypeTag.Char |
+                    TypeTag.Array |
+                    TypeTag.Dictionary |
+                    TypeTag.Null,
+                typeFn: common_types,
+                valueFn: (left, right) => left.type === TypeTag.Char &&
+                    right.type & (TypeTag.Number | TypeTag.Long)
+                    ? {
+                        type: TypeTag.Char,
+                        value: String.fromCharCode(left.value.charCodeAt(0) + Number(right.value)),
+                    }
+                    : left.type & (TypeTag.Number | TypeTag.Long) &&
+                        right.type === TypeTag.Char
+                        ? {
+                            type: TypeTag.Char,
+                            value: String.fromCharCode(right.value.charCodeAt(0) + Number(left.value)),
+                        }
+                        : {
+                            type: left.type,
+                            value: left.value + right.value,
+                        },
+            },
+            "-": {
+                allowed: TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double,
+                typeFn: common_types,
+                valueFn: (left, right) => ({
+                    type: left.type,
+                    value: left.value - right.value,
+                }),
+            },
+            "*": {
+                allowed: TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double,
+                typeFn: common_types,
+                valueFn: (left, right) => ({
+                    type: left.type,
+                    value: left.value * right.value,
+                }),
+            },
+            "/": {
+                allowed: TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double,
+                typeFn: common_types,
+                valueFn: (left, right) => right.value == 0 // "==" because it could be a bigint
+                    ? { type: left.type }
+                    : left.type === TypeTag.Number
+                        ? {
+                            type: left.type,
+                            value: Number(BigInt(left.value) / BigInt(right.value)),
+                        }
+                        : {
+                            type: left.type,
+                            value: left.value / right.value,
+                        },
+            },
+            "%": {
+                allowed: TypeTag.Number | TypeTag.Long,
+                typeFn: common_types,
+                valueFn: (left, right) => right.value == 0 // "==" because it could be a bigint
+                    ? { type: left.type }
+                    : {
+                        type: left.type,
+                        value: left.value % right.value,
+                    },
+            },
+            "&": {
+                allowed: TypeTag.Boolean | TypeTag.Number | TypeTag.Long,
+                typeFn: common_types,
+                valueFn: (left, right) => left.type & TypeTag.Boolean
+                    ? {
+                        type: left.type === TypeTag.True && right.type === TypeTag.True
+                            ? TypeTag.True
+                            : TypeTag.False,
+                    }
+                    : {
+                        type: left.type,
+                        value: left.value & right.value,
+                    },
+            },
+            "|": {
+                allowed: TypeTag.Boolean | TypeTag.Number | TypeTag.Long,
+                typeFn: common_types,
+                valueFn: (left, right) => left.type & TypeTag.Boolean
+                    ? {
+                        type: left.type === TypeTag.True || right.type === TypeTag.True
+                            ? TypeTag.True
+                            : TypeTag.False,
+                    }
+                    : {
+                        type: left.type,
+                        value: left.value | right.value,
+                    },
+            },
+            "^": {
+                allowed: TypeTag.Boolean | TypeTag.Number | TypeTag.Long,
+                typeFn: common_types,
+                valueFn: (left, right) => left.type & TypeTag.Boolean
+                    ? {
+                        type: (left.type === TypeTag.True) !== (right.type === TypeTag.True)
+                            ? TypeTag.True
+                            : TypeTag.False,
+                    }
+                    : {
+                        type: left.type,
+                        value: left.value ^ right.value,
+                    },
+            },
+            "<<": {
+                allowed: TypeTag.Number | TypeTag.Long,
+                typeFn: common_types,
+                valueFn: (left, right) => left.type === TypeTag.Long
+                    ? {
+                        type: TypeTag.Long,
+                        value: left.value << right.value,
+                    }
+                    : {
+                        type: TypeTag.Number,
+                        value: left.value << (right.value & 63),
+                    },
+            },
+            ">>": {
+                allowed: TypeTag.Number | TypeTag.Long,
+                typeFn: common_types,
+                valueFn: (left, right) => left.type === TypeTag.Long
+                    ? {
+                        type: TypeTag.Long,
+                        value: left.value >> right.value,
+                    }
+                    : {
+                        type: TypeTag.Number,
+                        value: left.value >> (right.value & 63),
+                    },
+            },
+            "==": {
+                allowed: TypeTag.Any,
+                typeFn: () => ({
+                    tag: TypeTag.Boolean,
+                    castArgs: false,
+                }),
+                valueFn: (left, right) => {
+                    const result = equalsCheck(left, right);
+                    return result === undefined
+                        ? result
+                        : { type: result ? TypeTag.True : TypeTag.False };
+                },
+            },
+            "!=": {
+                allowed: TypeTag.Any,
+                typeFn: () => ({
+                    tag: TypeTag.Boolean,
+                    castArgs: false,
+                }),
+                valueFn: (left, right) => {
+                    const result = equalsCheck(left, right);
+                    return result === undefined
+                        ? result
+                        : { type: result ? TypeTag.False : TypeTag.True };
+                },
+            },
+            "<=": {
+                allowed: TypeTag.Any,
+                typeFn: compare_types,
+                valueFn: (left, right) => ({
+                    type: left.value <= right.value
+                        ? TypeTag.True
+                        : TypeTag.False,
+                }),
+            },
+            ">=": {
+                allowed: TypeTag.Any,
+                typeFn: compare_types,
+                valueFn: (left, right) => ({
+                    type: left.value >= right.value
+                        ? TypeTag.True
+                        : TypeTag.False,
+                }),
+            },
+            "<": {
+                allowed: TypeTag.Any,
+                typeFn: compare_types,
+                valueFn: (left, right) => ({
+                    type: left.value < right.value
+                        ? TypeTag.True
+                        : TypeTag.False,
+                }),
+            },
+            ">": {
+                allowed: TypeTag.Any,
+                typeFn: compare_types,
+                valueFn: (left, right) => ({
+                    type: left.value > right.value
+                        ? TypeTag.True
+                        : TypeTag.False,
+                }),
+            },
+            instanceof: {
+                allowed: TypeTag.Any,
+                typeFn: () => ({
+                    tag: TypeTag.Boolean,
+                    castArgs: false,
+                }),
+                valueFn: (_left, _right) => undefined,
+            },
+            has: {
+                allowed: TypeTag.Any,
+                typeFn: () => ({
+                    tag: TypeTag.Boolean,
+                    castArgs: false,
+                }),
+                valueFn: (_left, _right) => undefined,
+            },
+        };
+    }
+    const info = operators[op];
+    if (!info)
+        return { type: TypeTag.Any };
+    const { tag, castArgs } = info.typeFn(left, right, info.allowed);
+    const result_type = { type: tag };
+    if (isExact(result_type) && castArgs !== false) {
+        left = castType(left, castArgs);
+        right = castType(right, castArgs);
+    }
+    if (hasValue(left) && hasValue(right)) {
+        const value = info.valueFn(left, right);
+        if (value) {
+            if (value.type === TypeTag.Float && value.value != null) {
+                value.value = roundToFloat(value.value);
+            }
+            return value;
+        }
+    }
+    return result_type;
+}
+function evaluateLogicalTypes(op, left, right) {
+    switch (op) {
+        case "&&":
+        case "and":
+            if (mustBeFalse(left)) {
+                return left;
+            }
+            else {
+                const result = evaluateBinaryTypes("&", left, right);
+                if ((left.type & TypeTag.Null) !== 0) {
+                    unionInto(result, { type: TypeTag.Null });
+                }
+                return result;
+            }
+        case "||":
+        case "or":
+            if (mustBeTrue(left)) {
+                return left;
+            }
+            else {
+                const result = evaluateBinaryTypes("|", left, right);
+                if ((left.type & TruthyTypes) !== 0) {
+                    unionInto(result, { type: left.type & TruthyTypes });
+                }
+                return result;
+            }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/type-flow/interp-call.ts
+
+
+
+function evaluateCall(state, node, callee, _args) {
+    while (!hasValue(callee) || callee.type !== TypeTag.Function) {
+        const name = node.callee.type === "Identifier"
+            ? node.callee
+            : node.callee.type === "MemberExpression" && !node.callee.computed
+                ? node.callee.property
+                : null;
+        if (name) {
+            const decls = state.allFunctions[name.name];
+            if (decls) {
+                callee = typeFromTypeStateNodes(state, decls);
+                if (hasValue(callee) && callee.type === TypeTag.Function) {
+                    break;
+                }
+            }
+        }
+        return { type: TypeTag.Any };
+    }
+    return (0,external_util_cjs_namespaceObject.reduce)(callee.value, (result, cur) => {
+        if (cur.node.returnType) {
+            const returnType = typeFromTypespec(state, cur.node.returnType.argument, cur.stack);
+            unionInto(result, returnType);
+        }
+        else {
+            result.type = TypeTag.Any;
+            delete result.value;
+        }
+        return result;
+    }, { type: TypeTag.Never });
+}
+
+;// CONCATENATED MODULE: ./src/type-flow/interp.ts
+
+
+
+
+
+
+
+
+function popIstate(istate, node) {
+    const item = istate.stack.pop();
+    if (!item) {
+        throw new Error("Unbalanced stack!");
+    }
+    if (item.node !== node) {
+        throw new Error("Stack mismatch");
+    }
+    return item;
+}
+function evaluateExpr(state, expr, typeMap) {
+    return interp_evaluate({ state, stack: [], typeMap }, expr);
+}
+function interp_evaluate(istate, node) {
+    let skipNode = null;
+    const post = (node) => {
+        if (istate.pre && node !== skipNode) {
+            const rep = istate.pre(node);
+            if (rep)
+                return rep;
+        }
+        evaluateNode(istate, node);
+        if (skipNode === node) {
+            skipNode = null;
+            return null;
+        }
+        return istate.post ? istate.post(node) : null;
+    };
+    const pre = (node) => {
+        switch (node.type) {
+            case "MemberExpression":
+                if ((0,external_api_cjs_namespaceObject.isLookupCandidate)(node)) {
+                    return ["object"];
+                }
+                break;
+            case "BinaryExpression":
+                if (node.operator === "as") {
+                    return ["left"];
+                }
+                break;
+            case "UnaryExpression":
+                if (node.operator === ":") {
+                    return [];
+                }
+                break;
+            case "AttributeList":
+                return [];
+            case "AssignmentExpression":
+                skipNode = node.left;
+                break;
+            case "UpdateExpression":
+                skipNode = node.argument;
+                break;
+            case "SizedArrayExpression":
+                return ["size"];
+            case "VariableDeclarator":
+                return ["init"];
+            case "CatchClause":
+                return ["body"];
+        }
+        return null;
+    };
+    traverseAst(node, pre, post);
+    const ret = istate.stack.pop();
+    if (isExpression(node)) {
+        if (!ret || node !== ret.node) {
+            throw new Error("evaluate failed to produce a value for an expression");
+        }
+    }
+    return ret;
+}
+function evaluateUnaryTypes(op, argument) {
+    switch (op) {
+        case "+":
+            return argument;
+        case "-":
+            return evaluateBinaryTypes("-", { type: TypeTag.Number, value: 0 }, argument);
+        case "!":
+        case "~":
+            if (hasValue(argument)) {
+                const left = argument.type & TypeTag.Boolean
+                    ? { type: TypeTag.True }
+                    : { type: TypeTag.Number, value: -1 };
+                return evaluateBinaryTypes("^", left, argument);
+            }
+            return {
+                type: argument.type & (TypeTag.Boolean | TypeTag.Number | TypeTag.Long),
+            };
+    }
+    throw new Error(`Unexpected unary operator ${op}`);
+}
+/*
+ * When an enumeration constant, or a constant cast to an
+ * enum type is used in an arithmetic context, its converted
+ * to its underlying type.
+ */
+function deEnumerate(t) {
+    if (hasValue(t) && t.type === TypeTag.Enum && t.value.value) {
+        return t.value.value;
+    }
+    if (t.type & TypeTag.Enum) {
+        return {
+            type: (t.type & ~TypeTag.Enum) | TypeTag.Numeric | TypeTag.String,
+        };
+    }
+    return t;
+}
+function pushScopedNameType(istate, node, embeddedEffects) {
+    let result;
+    if (istate.typeMap) {
+        result = istate.typeMap?.get(node);
+    }
+    else {
+        const [, results] = istate.state.lookup(node);
+        result =
+            results &&
+                results.reduce((cur, lookupDefn) => lookupDefn.results.reduce((cur, result) => {
+                    if (result.type !== "BinaryExpression" &&
+                        result.type !== "Identifier") {
+                        const type = typeFromTypeStateNode(istate.state, result, true);
+                        if (!cur) {
+                            cur = cloneType(type);
+                        }
+                        else {
+                            unionInto(cur, type);
+                        }
+                    }
+                    return cur;
+                }, cur), null);
+    }
+    istate.stack.push({
+        value: result || { type: TypeTag.Any },
+        embeddedEffects,
+        node,
+    });
+}
+function evaluateNode(istate, node) {
+    const { state, stack } = istate;
+    const push = (item) => {
+        if (!item) {
+            throw new Error("Pushing null");
+        }
+        istate.stack.push(item);
+    };
+    switch (node.type) {
+        case "BinaryExpression": {
+            if (node.operator === "as") {
+                push({
+                    value: typeFromTypespec(istate.state, node.right),
+                    embeddedEffects: false,
+                    node: node.right,
+                });
+            }
+            const right = popIstate(istate, node.right);
+            const left = popIstate(istate, node.left);
+            if (node.operator === "as") {
+                if (hasValue(right.value) && right.value.type === TypeTag.Enum) {
+                    if ((left.value.type & (TypeTag.Numeric | TypeTag.String)) ==
+                        left.value.type) {
+                        right.value.value.value = left.value;
+                        stack.push({
+                            value: right.value,
+                            embeddedEffects: left.embeddedEffects,
+                            node,
+                        });
+                        return;
+                    }
+                }
+                push({
+                    value: right.value,
+                    embeddedEffects: left.embeddedEffects,
+                    node,
+                });
+            }
+            else {
+                push({
+                    value: evaluateBinaryTypes(node.operator, deEnumerate(left.value), deEnumerate(right.value)),
+                    embeddedEffects: left.embeddedEffects || right.embeddedEffects,
+                    node,
+                });
+            }
+            break;
+        }
+        case "UnaryExpression":
+            if (node.operator === ":") {
+                push({
+                    value: { type: TypeTag.Symbol, value: node.argument.name },
+                    embeddedEffects: false,
+                    node,
+                });
+            }
+            else if (node.operator !== " as") {
+                const arg = popIstate(istate, node.argument);
+                push({
+                    value: evaluateUnaryTypes(node.operator, deEnumerate(arg.value)),
+                    embeddedEffects: arg.embeddedEffects,
+                    node,
+                });
+            }
+            break;
+        case "SizedArrayExpression": {
+            const arg = popIstate(istate, node.size);
+            push({
+                value: { type: TypeTag.Array },
+                embeddedEffects: arg.embeddedEffects,
+                node,
+            });
+            break;
+        }
+        case "ArrayExpression": {
+            const args = node.elements.length
+                ? stack.splice(-node.elements.length)
+                : [];
+            push({
+                value: {
+                    type: TypeTag.Array,
+                },
+                embeddedEffects: args.some((arg) => arg.embeddedEffects),
+                node,
+            });
+            break;
+        }
+        case "ObjectExpression": {
+            const args = node.properties.length
+                ? stack.splice(-node.properties.length * 2)
+                : [];
+            push({
+                value: {
+                    type: TypeTag.Dictionary,
+                },
+                embeddedEffects: args.some((arg) => arg.embeddedEffects),
+                node,
+            });
+            break;
+        }
+        case "ThisExpression": {
+            const self = (() => {
+                for (let i = state.stack.length; i--;) {
+                    const si = state.stack[i];
+                    if (si.type === "ClassDeclaration") {
+                        const klass = { type: TypeTag.Class, value: si };
+                        if ((istate.func?.attributes || 0) & StateNodeAttributes.STATIC) {
+                            return klass;
+                        }
+                        else {
+                            return { type: TypeTag.Object, value: { klass } };
+                        }
+                    }
+                    if (si.type === "ModuleDeclaration") {
+                        return { type: TypeTag.Module, value: si };
+                    }
+                }
+                return { type: TypeTag.Module };
+            })();
+            push({ value: self, embeddedEffects: false, node });
+            break;
+        }
+        case "LogicalExpression": {
+            const right = popIstate(istate, node.right);
+            const left = popIstate(istate, node.left);
+            push({
+                value: evaluateLogicalTypes(node.operator, deEnumerate(left.value), deEnumerate(right.value)),
+                embeddedEffects: left.embeddedEffects || right.embeddedEffects,
+                node,
+            });
+            break;
+        }
+        case "ConditionalExpression": {
+            const alternate = popIstate(istate, node.alternate);
+            const consequent = popIstate(istate, node.consequent);
+            const test = popIstate(istate, node.test);
+            const testType = deEnumerate(test.value);
+            if (mustBeTrue(testType)) {
+                push({
+                    value: consequent.value,
+                    embeddedEffects: test.embeddedEffects || consequent.embeddedEffects,
+                    node,
+                });
+            }
+            else if (mustBeFalse(testType)) {
+                push({
+                    value: alternate.value,
+                    embeddedEffects: test.embeddedEffects || alternate.embeddedEffects,
+                    node,
+                });
+            }
+            else {
+                const value = cloneType(consequent.value);
+                unionInto(value, alternate.value);
+                push({
+                    value,
+                    embeddedEffects: test.embeddedEffects ||
+                        alternate.embeddedEffects ||
+                        consequent.embeddedEffects,
+                    node,
+                });
+            }
+            break;
+        }
+        case "ParenthesizedExpression": {
+            const { value, embeddedEffects } = popIstate(istate, node.expression);
+            push({ value, embeddedEffects, node });
+            break;
+        }
+        case "Literal":
+            push({
+                value: typeFromLiteral(node),
+                embeddedEffects: false,
+                node,
+            });
+            break;
+        case "Identifier":
+            pushScopedNameType(istate, node, false);
+            break;
+        case "MemberExpression":
+            if (!(0,external_api_cjs_namespaceObject.isLookupCandidate)(node)) {
+                const property = popIstate(istate, node.property);
+                const object = popIstate(istate, node.object);
+                if (hasValue(object.value) &&
+                    object.value.type === TypeTag.Array &&
+                    property.value.type & (TypeTag.Number | TypeTag.Long)) {
+                    push({
+                        value: object.value.value,
+                        embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+                        node,
+                    });
+                    break;
+                }
+                if (hasValue(object.value) &&
+                    object.value.type === TypeTag.Dictionary &&
+                    property.value.type & object.value.value.key.type) {
+                    const value = { type: TypeTag.Null };
+                    unionInto(value, object.value.value.value);
+                    push({
+                        value,
+                        embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+                        node,
+                    });
+                    break;
+                }
+                push({
+                    value: { type: TypeTag.Any },
+                    embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+                    node,
+                });
+            }
+            else {
+                const object = popIstate(istate, node.object);
+                pushScopedNameType(istate, node, object.embeddedEffects);
+            }
+            break;
+        case "SequenceExpression": {
+            if (stack.length < node.expressions.length) {
+                throw new Error("Unbalanced stack");
+            }
+            if (node.expressions.length) {
+                const right = popIstate(istate, node.expressions[node.expressions.length - 1]);
+                if (node.expressions.length > 1) {
+                    right.embeddedEffects =
+                        stack
+                            .splice(1 - node.expressions.length)
+                            .some(({ embeddedEffects }) => embeddedEffects) ||
+                            right.embeddedEffects;
+                }
+                push({
+                    value: right.value,
+                    embeddedEffects: right.embeddedEffects,
+                    node,
+                });
+            }
+            break;
+        }
+        case "AssignmentExpression": {
+            const right = popIstate(istate, node.right);
+            const left = popIstate(istate, node.left);
+            if (node.operator === "=") {
+                push({
+                    value: right.value,
+                    embeddedEffects: true,
+                    node,
+                });
+            }
+            else {
+                push({
+                    value: evaluateBinaryTypes(node.operator.slice(0, -1), left.value, right.value),
+                    embeddedEffects: true,
+                    node,
+                });
+            }
+            break;
+        }
+        case "UpdateExpression": {
+            const right = { type: TypeTag.Number, value: 1 };
+            const left = popIstate(istate, node.argument);
+            push({
+                value: evaluateBinaryTypes(node.operator.slice(1), left.value, right),
+                embeddedEffects: true,
+                node,
+            });
+            break;
+        }
+        case "NewExpression": {
+            const [klass, ..._args] = stack.splice(-1 - node.arguments.length);
+            // we should check the arguments at some point...
+            const obj = { type: TypeTag.Object };
+            if (isExact(klass.value) && klass.value.type === TypeTag.Class) {
+                obj.value = { klass: klass.value };
+            }
+            push({ value: obj, embeddedEffects: true, node });
+            break;
+        }
+        case "CallExpression": {
+            const [callee, ...args] = stack.splice(-1 - node.arguments.length);
+            push({
+                value: evaluateCall(state, node, callee.value, args.map(({ value }) => value)),
+                embeddedEffects: true,
+                node,
+            });
+            break;
+        }
+        // Statements, and other
+        case "VariableDeclarator":
+        case "EnumStringMember":
+            if (node.init)
+                popIstate(istate, node.init);
+            break;
+        case "ExpressionStatement":
+            popIstate(istate, node.expression);
+            break;
+        case "ReturnStatement":
+            if (node.argument) {
+                popIstate(istate, node.argument);
+            }
+            break;
+        case "IfStatement":
+        case "WhileStatement":
+        case "DoWhileStatement":
+            popIstate(istate, node.test);
+            break;
+        case "SwitchStatement":
+            popIstate(istate, node.discriminant);
+            break;
+        case "SwitchCase":
+            if (node.test)
+                popIstate(istate, node.test);
+            break;
+        case "InstanceOfCase": {
+            const klass = popIstate(istate, node.id);
+            push({
+                value: { type: TypeTag.Boolean },
+                embeddedEffects: klass.embeddedEffects,
+                node,
+            });
+            break;
+        }
+        case "BlockStatement":
+        case "BreakStatement":
+        case "ContinueStatement":
+        case "TryStatement":
+            break;
+        case "ThrowStatement":
+            popIstate(istate, node.argument);
+            break;
+        case "ForStatement":
+            if (node.update)
+                popIstate(istate, node.update);
+            if (node.test)
+                popIstate(istate, node.test);
+            if (node.init && node.init.type !== "VariableDeclaration") {
+                popIstate(istate, node.init);
+            }
+            break;
+        case "ImportModule":
+            popIstate(istate, node.id);
+            break;
+        case "Using":
+            if (node.as)
+                popIstate(istate, node.as);
+            popIstate(istate, node.id);
+            break;
+        case "ClassDeclaration":
+        case "EnumDeclaration":
+        case "FunctionDeclaration":
+        case "ModuleDeclaration":
+        case "TypedefDeclaration":
+        case "VariableDeclaration":
+        case "Program":
+        case "TypeSpecList":
+        case "CatchClause":
+        case "CatchClauses":
+        case "EnumStringBody":
+        case "Property":
+        case "AttributeList":
+        case "Attributes":
+        case "TypeSpecPart":
+        case "ClassElement":
+        case "ClassBody":
+        case "MethodDefinition":
+        case "Block":
+        case "Line":
+        case "MultiLine":
+            break;
+        default:
+            unhandledType(node);
+    }
+}
+function roundToFloat(value) {
+    return new Float32Array([value])[0];
+}
+
+;// CONCATENATED MODULE: ./src/type-flow.ts
+
+
+
+
+
+
+
+
+const type_flow_logging = true;
+function type_flow_buildTypeInfo(state, func) {
+    if (!func.node.body || !func.stack)
+        return;
+    const { graph } = buildDataFlowGraph(state, func, () => false, false, true);
+    state = { ...state, stack: func.stack };
+    return propagateTypes(state, func, graph);
+}
+function mergeTypeState(to, from) {
+    let changes = false;
+    from.forEach((v, k) => {
+        const tov = to.get(k);
+        let result;
+        if (tov) {
+            if (!unionInto((result = cloneType(tov)), v))
+                return;
+        }
+        else {
+            result = v;
+        }
+        to.set(k, result);
+        changes = true;
+    });
+    return changes;
+}
+function printBlockHeader(block) {
+    console.log(block.order, `(${block.node?.loc?.source || "??"}:${block.node?.loc?.start.line || "??"})`, `Preds: ${(block.preds || [])
+        .map((block) => block.order)
+        .join(", ")}`);
+}
+function printBlockEvents(block, typeMap) {
+    (0,external_util_cjs_namespaceObject.forEach)(block.events, (event) => event.type !== "exn" &&
+        console.log(`    ${event.type}: ${event.decl ? declFullName(event.decl) : "??"} ${event.type === "ref" && typeMap && typeMap.has(event.node)
+            ? display(typeMap.get(event.node))
+            : ""}`));
+}
+function printBlockTrailer(block) {
+    console.log(`Succs: ${(block.succs || [])
+        .map((block) => block.order)
+        .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
+}
+function printBlockState(block, state) {
+    state.forEach((value, key) => {
+        console.log(`${(0,external_util_cjs_namespaceObject.map)(key, (k) => {
+            if (k.type === "Literal") {
+                return k.raw;
+            }
+            else if ((0,external_api_cjs_namespaceObject.isStateNode)(k)) {
+                return k.fullName;
+            }
+            else if (k.type === "BinaryExpression") {
+                return k.left.name;
+            }
+            else if (k.type === "Identifier") {
+                return k.name;
+            }
+            else if (k.type === "EnumStringMember") {
+                return k.id.name;
+            }
+            return "<unknown>";
+        }).join("|")} = ${display(value)}`);
+    });
+}
+function propagateTypes(state, func, graph) {
+    // We want to traverse the blocks in reverse post order, in
+    // order to propagate the "availability" of the types.
+    const order = getPostOrder(graph).reverse();
+    const queue = new DataflowQueue();
+    const blockStates = order.map((block, i) => {
+        block.order = i;
+        queue.enqueue(block);
+        return new Map();
+    });
+    if (type_flow_logging && process.env["TYPEFLOW_FUNC"] === func.fullName) {
+        order.forEach((block) => {
+            printBlockHeader(block);
+            printBlockEvents(block);
+            printBlockTrailer(block);
+        });
+    }
+    const typeMap = new Map();
+    const istate = {
+        state,
+        typeMap,
+        stack: [],
+    };
+    const modifiableDecl = (decls, callees) => (0,external_util_cjs_namespaceObject.some)(decls, (decl) => decl.type === "VariableDeclarator" &&
+        decl.node.kind === "var" &&
+        !(0,external_api_cjs_namespaceObject.isLocal)(decl) &&
+        (!callees ||
+            callees.some((callee) => functionMayModify(state, callee, decl))));
+    const declInitVal = (decls) => {
+        return (0,external_util_cjs_namespaceObject.reduce)(decls, (result, decl) => {
+            if (decl.type === "Identifier" || decl.type === "BinaryExpression") {
+                // It looks like this can happen due to catch clauses
+                // throw new Error(`Internal error: Unexpected function parameter`);
+                unionInto(result, { type: TypeTag.Any });
+                return result;
+            }
+            const declType = decl.type === "Literal"
+                ? typeFromLiteral(decl)
+                : typeFromTypeStateNode(state, decl, true);
+            unionInto(result, declType);
+            return result;
+        }, { type: TypeTag.Never });
+    };
+    const head = blockStates[0];
+    // set the parameters to their initial types
+    func.node.params.forEach((param) => {
+        head.set(param, param.type === "BinaryExpression"
+            ? typeFromTypespec(state, param.right)
+            : { type: TypeTag.Any });
+    });
+    // set every other modifiable (ie non-local variables that
+    // could be affected by "mod" events) decl to its initial
+    // value too.
+    order.forEach((block) => {
+        (0,external_util_cjs_namespaceObject.forEach)(block.events, (event) => {
+            if (event.type === "ref" &&
+                !head.has(event.decl) &&
+                modifiableDecl(event.decl)) {
+                head.set(event.decl, declInitVal(event.decl));
+            }
+        });
+    });
+    while (!queue.empty()) {
+        const top = queue.dequeue();
+        if (top.order === undefined) {
+            throw new Error(`Unreachable block was visited!`);
+        }
+        const curState = new Map(blockStates[top.order]);
+        if (top.events) {
+            for (let i = 0; i < top.events.length; i++) {
+                const event = top.events[i];
+                if (event.mayThrow && top.exsucc) {
+                    const succState = blockStates[top.exsucc.order];
+                    if (succState) {
+                        if (mergeTypeState(succState, curState)) {
+                            queue.enqueue(top.exsucc);
+                        }
+                    }
+                }
+                switch (event.type) {
+                    case "ref": {
+                        let curType = curState.get(event.decl);
+                        if (!curType) {
+                            curState.set(event.decl, (curType = declInitVal(event.decl)));
+                        }
+                        typeMap.set(event.node, curType);
+                        break;
+                    }
+                    case "mod": {
+                        curState.forEach((_type, decls) => {
+                            if (modifiableDecl(decls, event.callees)) {
+                                curState.set(decls, declInitVal(decls));
+                            }
+                        });
+                        if (event.node.type === "CallExpression") {
+                            typeMap.set(event.node, interp_evaluate(istate, event.node).value);
+                        }
+                        break;
+                    }
+                    case "def": {
+                        const beforeType = curState.get(event.decl);
+                        const lval = event.node.type === "UpdateExpression"
+                            ? event.node.argument
+                            : event.node.type === "AssignmentExpression"
+                                ? event.node.left
+                                : null;
+                        if (beforeType && lval) {
+                            typeMap.set(lval, beforeType);
+                        }
+                        const expr = event.node.type === "VariableDeclarator"
+                            ? event.node.init || null
+                            : event.node;
+                        if (expr) {
+                            const type = interp_evaluate(istate, expr);
+                            curState.set(event.decl, type.value);
+                        }
+                        else {
+                            curState.set(event.decl, { type: TypeTag.Any });
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        top.succs?.forEach((succ) => {
+            if (succ.order == null) {
+                throw new Error("Unreachable block was visited");
+            }
+            if (mergeTypeState(blockStates[succ.order], curState)) {
+                queue.enqueue(succ);
+            }
+        });
+    }
+    if (type_flow_logging && process.env["TYPEFLOW_FUNC"] === func.fullName) {
+        order.forEach((block) => {
+            printBlockHeader(block);
+            printBlockState(block, blockStates[block.order]);
+            printBlockEvents(block, typeMap);
+            printBlockTrailer(block);
+        });
+        console.log("====== TypeMap =====");
+        typeMap.forEach((value, key) => {
+            console.log(`${(0,external_api_cjs_namespaceObject.formatAst)(key)} = ${display(value)}`);
+        });
+    }
+    return istate;
+}
+
+;// CONCATENATED MODULE: ./src/type-flow/could-be.ts
+
+
+
+
+/*
+ * Determine whether a value conforming to a's type could also
+ * be a value conforming to b's type.
+ *
+ * This is symmetric, and a subtypeOf b, or b subtypeOf a implies
+ * a couldBe b.
+ */
+function couldBe(a, b) {
+    const common = a.type & b.type & ~TypeTag.Typedef;
+    if (common) {
+        if (a.value == null)
+            return true;
+        if (b.value == null)
+            return true;
+        let result = false;
+        forEachUnionComponent(a, common, (bit, avalue) => {
+            if (avalue == null) {
+                result = true;
+                return false;
+            }
+            const bvalue = getUnionComponent(b, bit);
+            if (bvalue == null || couldBeValue(bit, avalue, bvalue)) {
+                result = true;
+                return false;
+            }
+            return true;
+        });
+        if (result)
+            return true;
+    }
+    if ((a.type & TypeTag.Enum && b.type & (TypeTag.Numeric | TypeTag.String)) ||
+        (b.type & TypeTag.Enum && a.type & (TypeTag.Numeric | TypeTag.String))) {
+        return true;
+    }
+    if (a.type & TypeTag.Object &&
+        b.type & ObjectLikeTagsConst &&
+        getObjectValue(a) == null) {
+        /*
+         * converting Number, String etc to and from Object is ok,
+         * because they *are* subtypes of Object. But converting
+         * them from `Object<something>` is not, because `something`
+         * will never be Number, String, etc.
+         *
+         * So we only add Object when the other side has an unqualified
+         * object type.
+         */
+        return true;
+    }
+    if (b.type & TypeTag.Object &&
+        a.type & ObjectLikeTagsConst &&
+        getObjectValue(b) == null) {
+        return true;
+    }
+    const checkTypdef = (t, other) => {
+        const typedef = getUnionComponent(t, TypeTag.Typedef);
+        return (typedef &&
+            (0,external_util_cjs_namespaceObject.some)(typedef, (td) => {
+                if (!td.resolvedType) {
+                    throw new Error(`No resolved type for ${td.fullName} in 'couldBe'`);
+                }
+                return couldBe(td.resolvedType, other);
+            }));
+    };
+    if (a.type & TypeTag.Typedef && checkTypdef(a, b)) {
+        return true;
+    }
+    if (b.type & TypeTag.Typedef && checkTypdef(b, a)) {
+        return true;
+    }
+    return false;
+}
+function couldBeValue(bit, avalue, bvalue) {
+    switch (bit) {
+        case TypeTag.Null:
+        case TypeTag.False:
+        case TypeTag.True:
+        case TypeTag.Typedef:
+            throw new Error(`Unexpected TypeTag '${TypeTag[bit]}'`);
+        case TypeTag.Number:
+        case TypeTag.Long:
+        case TypeTag.Float:
+        case TypeTag.Double:
+        case TypeTag.String:
+        case TypeTag.Char:
+        case TypeTag.Symbol:
+            return avalue === bvalue;
+        case TypeTag.Array:
+            return couldBe(avalue, bvalue);
+        case TypeTag.Dictionary: {
+            const adict = avalue;
+            const bdict = bvalue;
+            return couldBe(adict.key, bdict.key) && couldBe(adict.value, bdict.value);
+        }
+        case TypeTag.Module:
+        case TypeTag.Function: {
+            const asd = avalue;
+            const bsd = bvalue;
+            // quadratic :-(
+            return (0,external_util_cjs_namespaceObject.some)(asd, (sna) => (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => sna === snb));
+        }
+        case TypeTag.Class: {
+            const asd = avalue;
+            const bsd = bvalue;
+            return (0,external_util_cjs_namespaceObject.some)(asd, (sna) => {
+                const superA = (0,external_api_cjs_namespaceObject.getSuperClasses)(sna);
+                return (0,external_util_cjs_namespaceObject.some)(bsd, (snb) => {
+                    if (sna === snb || (superA && superA.has(snb))) {
+                        return true;
+                    }
+                    const superB = (0,external_api_cjs_namespaceObject.getSuperClasses)(snb);
+                    return superB && superB.has(sna);
+                });
+            });
+        }
+        case TypeTag.Object: {
+            const aobj = avalue;
+            const bobj = bvalue;
+            return couldBe(aobj.klass, bobj.klass) && couldBeObj(aobj.obj, bobj.obj);
+        }
+        case TypeTag.Enum: {
+            const aenum = avalue;
+            const benum = bvalue;
+            return (aenum.enum === benum.enum &&
+                (!aenum.value || !benum.value || couldBe(aenum.value, benum.value)));
+        }
+        default:
+            unhandledType(bit);
+    }
+}
+function couldBeObj(a, b) {
+    if (!a || !b)
+        return true;
+    return Object.entries(a).every(([key, value]) => {
+        if (!(0,external_api_cjs_namespaceObject.hasProperty)(b, key))
+            return true;
+        return couldBe(value, b[key]);
+    });
+}
+
+;// CONCATENATED MODULE: ./src/type-flow/optimize.ts
+
+
+
+
+
+
+
+
+function optimizeFunction(state, func) {
+    const istate = buildTypeInfo(state, func);
+    if (!istate)
+        return;
+    evaluate({
+        ...istate,
+        pre(node) {
+            return beforeEvaluate(this, node);
+        },
+        post(node) {
+            return afterEvaluate(this, node);
+        },
+    }, func.node.body);
+}
+function beforeEvaluate(istate, node) {
+    switch (node.type) {
+        case "ConditionalExpression": {
+            let alternate = popIstate(istate, node.alternate);
+            let consequent = popIstate(istate, node.consequent);
+            const test = popIstate(istate, node.test);
+            const result = mustBeTrue(test.value)
+                ? true
+                : mustBeFalse(test.value)
+                    ? false
+                    : null;
+            if (result !== null) {
+                if (!test.embeddedEffects) {
+                    const arg = result ? consequent : alternate;
+                    istate.stack.push(arg);
+                    return result ? node.consequent : node.alternate;
+                }
+            }
+            if (node.alternate &&
+                node.test.type === "UnaryExpression" &&
+                node.test.operator === "!" &&
+                test.value.type === TypeTag.Boolean) {
+                const alternateNode = node.alternate;
+                node.alternate = node.consequent;
+                node.consequent = alternateNode;
+                const tmp = alternate;
+                alternate = consequent;
+                consequent = tmp;
+                test.node = node.test = node.test.argument;
+            }
+            if (test.value.type === TypeTag.Boolean &&
+                ((consequent.value.type === TypeTag.True &&
+                    alternate.value.type === TypeTag.False) ||
+                    (consequent.value.type === TypeTag.False &&
+                        alternate.value.type === TypeTag.True)) &&
+                !consequent.embeddedEffects &&
+                !alternate.embeddedEffects) {
+                if (consequent.value.type === TypeTag.False) {
+                    test.node = wrap({
+                        type: "UnaryExpression",
+                        operator: "!",
+                        argument: node.test,
+                        prefix: true,
+                    }, test.node.loc);
+                }
+                istate.stack.push(test);
+                return test.node;
+            }
+            istate.stack.push(test, consequent, alternate);
+            break;
+        }
+        case "IfStatement": {
+            const test = popIstate(istate, node.test);
+            const result = mustBeTrue(test.value)
+                ? true
+                : mustBeFalse(test.value)
+                    ? false
+                    : null;
+            if (result !== null) {
+                const rep = result ? node.consequent : node.alternate || false;
+                if (!test.embeddedEffects) {
+                    return rep;
+                }
+                const estmt = wrap({ type: "ExpressionStatement", expression: node.test }, node.loc);
+                if (!rep) {
+                    return estmt;
+                }
+                if (rep.type === "BlockStatement") {
+                    rep.body.unshift(estmt);
+                    return rep;
+                }
+            }
+            if (node.alternate &&
+                node.test.type === "UnaryExpression" &&
+                node.test.operator === "!" &&
+                test.value.type === TypeTag.Boolean) {
+                const alternate = node.alternate;
+                node.alternate = node.consequent;
+                node.consequent = alternate;
+                test.node = node.test = node.test.argument;
+            }
+            istate.stack.push(test);
+            break;
+        }
+        case "WhileStatement":
+        case "DoWhileStatement": {
+            const test = popIstate(istate, node.test);
+            if (!test.embeddedEffects) {
+                if (mustBeFalse(test.value)) {
+                    return node.type === "WhileStatement" ? false : node.body;
+                }
+            }
+            istate.stack.push(test);
+            break;
+        }
+        case "BinaryExpression":
+            if (node.operator === "has" &&
+                node.right.type === "UnaryExpression" &&
+                node.right.operator === ":") {
+                const [left, right] = istate.stack.slice(-2);
+                if (left.embeddedEffects ||
+                    right.embeddedEffects ||
+                    !hasValue(left.value) ||
+                    !hasValue(right.value) ||
+                    !(left.value.type & (TypeTag.Module | TypeTag.Class))) {
+                    break;
+                }
+                const id = node.right.argument;
+                if ((0,external_util_cjs_namespaceObject.every)(left.value.value, (m) => {
+                    if (hasProperty(m.decls, id.name))
+                        return false;
+                    // This is overkill, since we've already looked up
+                    // node.left, but the actual lookup rules are complicated,
+                    // and embedded within state.lookup; so just defer to that.
+                    return (istate.state.lookup({
+                        type: "MemberExpression",
+                        object: node.left,
+                        property: id,
+                        computed: false,
+                    })[1] == null);
+                })) {
+                    popIstate(istate, node.right);
+                    popIstate(istate, node.left);
+                    const rep = wrap({ type: "Literal", value: false, raw: "false" }, node.loc);
+                    istate.stack.push({
+                        value: { type: TypeTag.False },
+                        embeddedEffects: false,
+                        node: rep,
+                    });
+                    return rep;
+                }
+            }
+            else {
+                const rep = tryCommuteAndAssociate(istate, node);
+                if (rep)
+                    return rep;
+                const level = istate.state.config?.checkTypes === "OFF"
+                    ? null
+                    : istate.state.config?.checkTypes || "WARNING";
+                if (!level)
+                    break;
+                if (node.operator === "==" || node.operator === "!=") {
+                    const [{ value: left }, { value: right }] = istate.stack.slice(-2);
+                    if ((left.type === TypeTag.Null && !(right.type & TypeTag.Null)) ||
+                        (right.type === TypeTag.Null && !(left.type & TypeTag.Null))) {
+                        (0,external_api_cjs_namespaceObject.diagnostic)(istate.state, node.loc, `This comparison seems redundant because ${(0,external_api_cjs_namespaceObject.formatAst)(left.type === TypeTag.Null ? node.right : node.left)} should never be null`, level);
+                    }
+                }
+                else if (node.operator === "as") {
+                    const [{ value: left }] = istate.stack.slice(-1);
+                    const right = typeFromTypespec(istate.state, node.right);
+                    if (!couldBe(left, right)) {
+                        (0,external_api_cjs_namespaceObject.diagnostic)(istate.state, node.loc, `The type ${display(left)} cannot be converted to ${display(right)} because they have nothing in common`, level);
+                    }
+                }
+            }
+            break;
+        case "LogicalExpression": {
+            const [left, right] = istate.stack.slice(-2);
+            const isAnd = node.operator === "&&" || node.operator === "and";
+            if (isAnd ? mustBeFalse(left.value) : mustBeTrue(left.value)) {
+                popIstate(istate, node.right);
+                return node.left;
+            }
+            if (
+            // bail if left could be anything other than bool/integer
+            (left.value.type &
+                (TypeTag.Boolean | TypeTag.Number | TypeTag.Long)) !==
+                left.value.type ||
+                // bail if left could be boolean AND it could be integer
+                (left.value.type & TypeTag.Boolean &&
+                    left.value.type & (TypeTag.Number | TypeTag.Long)) ||
+                // bail if right doesn't match left
+                (right.value.type &
+                    (left.value.type & TypeTag.Boolean
+                        ? TypeTag.Boolean
+                        : TypeTag.Number | TypeTag.Long)) !==
+                    right.value.type) {
+                break;
+            }
+            if (right.value.type === (isAnd ? TypeTag.True : TypeTag.False) &&
+                !right.embeddedEffects &&
+                (left.value.type & TypeTag.Boolean) === left.value.type) {
+                popIstate(istate, node.right);
+                return node.left;
+            }
+            if (isAnd ? !mustBeTrue(left.value) : !mustBeFalse(left.value)) {
+                break;
+            }
+            if (!(left.value.type & ~TypeTag.Boolean)) {
+                // the left type is boolean, so the
+                // `&` or `|` would be a no-op. We
+                // need to check that its side-effect
+                // free. Just cheap checks for now.
+                if (!left.embeddedEffects) {
+                    popIstate(istate, node.right);
+                    popIstate(istate, node.left);
+                    istate.stack.push(right);
+                    return node.right;
+                }
+            }
+            const rep = node;
+            rep.type = "BinaryExpression";
+            rep.operator = isAnd ? "&" : "|";
+            break;
+        }
+    }
+    return null;
+}
+function afterEvaluate(istate, node) {
+    switch (node.type) {
+        case "IfStatement":
+            if (node.alternate &&
+                node.alternate.type === "BlockStatement" &&
+                !node.alternate.body.length) {
+                delete node.alternate;
+            }
+            break;
+    }
+    if (isExpression(node) && node.type !== "Literal") {
+        const top = istate.stack[istate.stack.length - 1];
+        if (!top.embeddedEffects && hasValue(top.value)) {
+            const rep = mcExprFromType(top.value);
+            if (rep) {
+                top.node = rep;
+                return withLoc(rep, node, node);
+            }
+        }
+    }
+    return null;
+}
+function identity(istate, node, left, right, allowedTypes, target) {
+    if (hasValue(right.value) &&
+        right.value.type & allowedTypes &&
+        !(left.value.type & ~allowedTypes) &&
+        Number(right.value.value) === target) {
+        // a +/- 0 => a
+        // but we still need to check that the type of the zero
+        // doesn't change the type of the result.
+        if (right.value.type === TypeTag.Number ||
+            (right.value.type === TypeTag.Long &&
+                !(left.value.type & ~(TypeTag.Long | TypeTag.Double))) ||
+            (right.value.type === TypeTag.Float &&
+                !(left.value.type & ~(TypeTag.Float | TypeTag.Double))) ||
+            (right.value.type === TypeTag.Double &&
+                left.value.type === TypeTag.Double)) {
+            istate.stack.pop();
+            return node.left;
+        }
+    }
+    return null;
+}
+function zero(istate, node, left, right, allowedTypes, target) {
+    if (hasValue(right.value) &&
+        right.value.type & allowedTypes &&
+        !(left.value.type & ~allowedTypes) &&
+        Number(right.value.value) === target) {
+        // a * 0 => 0
+        // but we still need to check that the type of a
+        // doesn't change the type of the zero.
+        if ((right.value.type === TypeTag.Number &&
+            left.value.type === TypeTag.Number) ||
+            (right.value.type === TypeTag.Long &&
+                !(left.value.type & ~(TypeTag.Long | TypeTag.Number))) ||
+            (right.value.type === TypeTag.Float &&
+                !(left.value.type & ~(TypeTag.Float | TypeTag.Number))) ||
+            right.value.type === TypeTag.Double) {
+            istate.stack.splice(-2, 1);
+            return node.right;
+        }
+    }
+    return null;
+}
+function tryIdentity(istate, node, left, right) {
+    switch (node.operator) {
+        case "+":
+        case "-": {
+            const rep = identity(istate, node, left, right, TypeTag.Numeric, 0);
+            if (rep)
+                return rep;
+            if (node.right.type === "UnaryExpression" &&
+                node.right.operator === "-") {
+                // We can convert a +/- -b to a -/+ b, but we have to know
+                // something about the types. eg if b is Number, with the
+                // value -2^31, negating b will leave the value as -2^31.
+                // This doesn't matter if the a is also Number, but if
+                // a might be Long, Float or Double, we would change the
+                // result. Similarly for Long and -2^63
+                if (!((left.value.type | right.value.type) & ~TypeTag.Numeric) &&
+                    (right.value.type & TypeTag.Number // Negating -2^31 goes wrong if left is a wider type
+                        ? !(left.value.type &
+                            (TypeTag.Long | TypeTag.Float | TypeTag.Double))
+                        : right.value.type & TypeTag.Long // Negating -2^63 goes wrong if left is a float/double
+                            ? !(left.value.type & (TypeTag.Float | TypeTag.Double))
+                            : true)) {
+                    right.value = evaluateBinaryTypes("-", { type: TypeTag.Number, value: 0 }, right.value);
+                    right.node = node.right.argument;
+                    node.right = right.node;
+                    node.operator = node.operator === "+" ? "-" : "+";
+                }
+            }
+            break;
+        }
+        case "*": {
+            const rep = zero(istate, node, left, right, TypeTag.Numeric, 0);
+            if (rep)
+                return rep;
+            // fall through
+        }
+        case "/": {
+            const rep = identity(istate, node, left, right, TypeTag.Numeric, 1);
+            if (rep)
+                return rep;
+            break;
+        }
+        case "|": {
+            const rep = zero(istate, node, left, right, TypeTag.Number | TypeTag.Long, -1);
+            if (rep)
+                return rep;
+            // fall through
+        }
+        case "^": {
+            const rep = identity(istate, node, left, right, TypeTag.Number | TypeTag.Long, 0);
+            if (rep)
+                return rep;
+            break;
+        }
+        case "&": {
+            const rep = zero(istate, node, left, right, TypeTag.Number | TypeTag.Long, 0) ||
+                identity(istate, node, left, right, TypeTag.Number | TypeTag.Long, -1);
+            if (rep)
+                return rep;
+            break;
+        }
+    }
+    return null;
+}
+function tryCommuteAndAssociate(istate, node) {
+    let [left, right] = istate.stack.slice(-2);
+    // no need to do anything if both sides are constants
+    if (!right || (hasValue(left.value) && hasValue(right.value))) {
+        return null;
+    }
+    switch (node.operator) {
+        case "+":
+            // Addition is only commutative/associative if both arguments
+            // are numeric, or one argument is Number, and the other is Char
+            if (left.value.type & ~(TypeTag.Numeric | TypeTag.Char) ||
+                right.value.type & ~(TypeTag.Numeric | TypeTag.Char) ||
+                left.value.type & right.value.type & TypeTag.Char) {
+                break;
+            }
+        // fallthrough
+        case "*":
+        case "&":
+        case "|":
+        case "^":
+            // flip the left argument to the right if the left has
+            // a known value, but the right does not, or if the
+            // top operator is additive, and the left operand is
+            // negated, and the right operand is not.
+            if (!left.embeddedEffects &&
+                (hasValue(left.value) ||
+                    (!right.embeddedEffects &&
+                        node.operator === "+" &&
+                        node.left.type === "UnaryExpression" &&
+                        node.left.operator === "-" &&
+                        (node.right.type !== "UnaryExpression" ||
+                            node.right.operator !== "-")))) {
+                const l = node.left;
+                node.left = node.right;
+                node.right = l;
+                istate.stack.splice(-2, 2, right, left);
+                const r = right;
+                right = left;
+                left = r;
+            }
+        // fallthrough
+        case "-":
+            if (tryReAssociate(istate, node, left, right)) {
+                [left, right] = istate.stack.slice(-2);
+            }
+    }
+    return tryIdentity(istate, node, left, right);
+}
+/*
+ * Try to reorder (a op K1) op K2 => a op (K1 op K2),
+ * and fold K1 op K2.
+ *
+ * Failing that,
+ * Try to reorder (a op K1) op (b op K2) as
+ * (a op b) op (K1 op K2), and fold K1 op K2.
+ *
+ * Failing that,
+ * Try to reorder (a op K) op b => (a op b) op K
+ * so that constants float up and to the right.
+ * This helps because now ((a op K1) op b) op K2
+ * becomes ((a op b) op K1) op K2, and we can
+ * fold K1 op K2 by the first transformation.
+ *
+ * Floating point arithmetic isn't really associative
+ * though, so we mostly suppress this when Floats
+ * and Doubles may be involved; except that
+ * (a + K1) + K2 can be safely converted to
+ * a + (K1 + K2) if K1 and K2 have the same sign.
+ */
+function tryReAssociate(istate, node, left, right) {
+    if (node.left.type !== "BinaryExpression" ||
+        (node.left.operator !== node.operator &&
+            !(node.operator === "+" && node.left.operator === "-") &&
+            !(node.operator === "-" && node.left.operator === "+"))) {
+        return false;
+    }
+    const lr = ast_getLiteralNode(node.left.right);
+    if (!lr)
+        return false;
+    const leftRight = interp_evaluate(istate, lr);
+    if (!hasValue(leftRight.value))
+        return false;
+    if (hasValue(right.value)) {
+        // (ll + lr) + r => ll + (r + lr)
+        // (ll - lr) - r => ll - (r + lr)
+        // (ll + lr) - r => ll + (r - lr)
+        // (ll - lr) + r => ll - (r - lr)
+        const tmpNode = {
+            type: "BinaryExpression",
+            operator: node.operator === "+" || node.operator === "-"
+                ? node.operator === node.left.operator
+                    ? "+"
+                    : "-"
+                : node.operator,
+            left: node.right,
+            right: node.left.right,
+        };
+        if (tmpNode.operator === "+" || tmpNode.operator === "-") {
+            if (leftRight.value.type & (TypeTag.Float | TypeTag.Double) ||
+                right.value.type & (TypeTag.Float | TypeTag.Double)) {
+                // we don't want to fold "a + 1.0 - 1.0" because
+                // it could be there for rounding purposes
+                const lsign = right.value.value < 0;
+                const rsign = leftRight.value.value < 0 === (tmpNode.operator === "+");
+                if (lsign !== rsign)
+                    return false;
+            }
+        }
+        const repType = interp_evaluate(istate, tmpNode);
+        if (!hasValue(repType.value))
+            return false;
+        const repNode = mcExprFromType(repType.value);
+        if (!repNode)
+            return false;
+        left.node = node.left = node.left.left;
+        node.right = repNode;
+        istate.stack.splice(-1, 1, repType);
+        repType.node = repNode;
+        return true;
+    }
+    if (leftRight.value.type !== left.value.type ||
+        leftRight.value.type !== right.value.type ||
+        leftRight.value.type & (TypeTag.Float | TypeTag.Double)) {
+        return false;
+    }
+    if (node.right.type === "BinaryExpression" &&
+        (node.right.operator === node.operator ||
+            ((node.operator === "+" || node.operator === "-") &&
+                (node.right.operator === "+" || node.right.operator === "-")))) {
+        // (a + K1) + (b + K2) => (a + b) + (K1 + K2)
+        const rr = ast_getLiteralNode(node.right.right);
+        if (!rr)
+            return false;
+        const rightRight = interp_evaluate(istate, rr);
+        if (!hasValue(rightRight.value))
+            return false;
+        const rightOp = node.operator === "+" || node.operator === "-"
+            ? ((node.left.operator === "+") === (node.right.operator === "+")) ===
+                (node.operator === "+")
+                ? "+"
+                : "-"
+            : node.operator;
+        const topOp = node.left.operator;
+        const leftOp = node.operator;
+        const rightType = evaluateBinaryTypes(rightOp, leftRight.value, rightRight.value);
+        if (!hasValue(rightType))
+            return false;
+        const repNode = mcExprFromType(rightType);
+        if (!repNode)
+            return false;
+        node.left.right = node.right.left;
+        node.right = repNode;
+        node.left.operator = leftOp;
+        node.operator = topOp;
+        istate.stack.splice(-1, 1, {
+            value: rightType,
+            node: repNode,
+            embeddedEffects: false,
+        });
+        return true;
+    }
+    const op = node.operator;
+    node.operator = node.left.operator;
+    node.left.operator = op;
+    leftRight.node = node.left.right;
+    node.left.right = node.right;
+    node.right = leftRight.node;
+    istate.stack.splice(-1, 1, leftRight);
+    return true;
+}
+
+;// 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();
+            const stack = [];
+            traverseAst(node, (node) => {
+                switch (node.type) {
+                    case "SwitchCase":
+                        stack.push(node.consequent);
+                        break;
+                    case "BlockStatement":
+                        stack.push(node.body);
+                        break;
+                }
+            }, (node) => {
+                switch (node.type) {
+                    case "SwitchCase":
+                    case "BlockStatement":
+                        stack.pop();
+                        break;
+                    case "VariableDeclaration": {
+                        node.declarations.forEach((decl, i) => {
+                            const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(decl.id);
+                            if (hasProperty(toRemove, name)) {
+                                const info = varDeclarations.get(node);
+                                if (info) {
+                                    info.indices.push(i);
+                                }
+                                else {
+                                    varDeclarations.set(node, {
+                                        parent: stack[stack.length - 1],
+                                        indices: [i],
+                                    });
+                                }
+                            }
+                        });
+                        break;
                     }
                     case "ExpressionStatement":
                         if (node.expression.type === "AssignmentExpression") {
@@ -7709,6 +10690,9 @@ function cleanupUnusedVars(state, node) {
 
 
 
+
+
+
 function collectClassInfo(state) {
     const toybox = state.stack[0].decls["Toybox"][0];
     const lang = toybox.decls["Lang"][0];
@@ -7786,7 +10770,7 @@ function collectClassInfo(state) {
                 funcs.forEach((f) => {
                     if (f.type === "FunctionDeclaration" &&
                         !(f.attributes & StateNodeAttributes.STATIC)) {
-                        (0,external_api_cjs_namespaceObject.markInvokeClassMethod)(f);
+                        (0,external_api_cjs_namespaceObject.markInvokeClassMethod)(state, f);
                     }
                 });
             });
@@ -7866,7 +10850,7 @@ async function analyze(fnMap, resourcesMap, manifestXML, config) {
                     if (scope.type == "FunctionDeclaration") {
                         if (markApi) {
                             node.body = null;
-                            scope.info = (0,external_api_cjs_namespaceObject.getApiFunctionInfo)(scope);
+                            scope.info = (0,external_api_cjs_namespaceObject.getApiFunctionInfo)(state, scope);
                             delete scope.stack;
                         }
                         const allFuncs = state.allFunctions;
@@ -7944,7 +10928,7 @@ function reportMissingSymbols(state, config) {
                                 return false;
                             });
                         })) {
-                        diagnostic(state, node.loc, `The expression ${(0,external_api_cjs_namespaceObject.formatAst)(node)} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
+                        (0,external_api_cjs_namespaceObject.diagnostic)(state, node.loc, `The expression ${(0,external_api_cjs_namespaceObject.formatAst)(node)} will fail at runtime using sdk-4.1.6`, compiler2DiagnosticType);
                     }
                     return undefined;
                 }
@@ -7954,7 +10938,7 @@ function reportMissingSymbols(state, config) {
                         return undefined;
                     }
                 }
-                diagnostic(state, node.loc, `Undefined symbol ${nodeStr || (0,external_api_cjs_namespaceObject.formatAst)(node)}`, diagnosticType);
+                (0,external_api_cjs_namespaceObject.diagnostic)(state, node.loc, `Undefined symbol ${nodeStr || (0,external_api_cjs_namespaceObject.formatAst)(node)}`, diagnosticType);
                 return false;
             });
         };
@@ -7993,405 +10977,53 @@ function getLiteralFromDecls(lookupDefns) {
     }
     return null;
 }
-function getLiteralNode(node) {
-    if (node == null)
-        return null;
-    if (node.type == "Literal")
-        return node;
-    if (node.type == "BinaryExpression" && node.operator == "as") {
-        return getLiteralNode(node.left) && node;
-    }
-    if (node.type == "UnaryExpression") {
-        if (node.argument.type != "Literal")
-            return null;
-        switch (node.operator) {
-            case "-": {
-                const [arg, type] = getNodeValue(node.argument);
-                if (type === "Number" || type === "Long") {
-                    return replacementLiteral(node, -arg.value, type);
-                }
-            }
-        }
-    }
-    return null;
-}
-function fullTypeName(state, tsp) {
-    if (typeof tsp.name === "string") {
-        return tsp.name;
-    }
-    const [, results] = state.lookupType(tsp.name);
-    if (results && results.length === 1 && results[0].results.length === 1) {
-        const result = results[0].results[0];
-        if ((0,external_api_cjs_namespaceObject.isStateNode)(result)) {
-            return result.fullName;
-        }
-    }
-    return null;
-}
-function isBooleanExpression(state, node) {
-    switch (node.type) {
-        case "Literal":
-            return typeof node.value === "boolean";
-        case "BinaryExpression":
-            switch (node.operator) {
-                case "==":
-                case "!=":
-                case "<=":
-                case ">=":
-                case "<":
-                case ">":
-                    return true;
-                case "as":
-                    return node.right.ts.length === 1 &&
-                        node.right.ts[0].type === "TypeSpecPart" &&
-                        node.right.ts[0].name &&
-                        fullTypeName(state, node.right.ts[0]) === "$.Toybox.Lang.Boolean"
-                        ? true
-                        : false;
-            }
-            return false;
-        case "LogicalExpression":
-            return (isBooleanExpression(state, node.left) &&
-                isBooleanExpression(state, node.right));
-        case "UnaryExpression":
-            return node.operator === "!" && isBooleanExpression(state, node.argument);
-    }
-    return false;
-}
-function roundToFloat(value) {
-    return new Float32Array([value])[0];
-}
-function replacementLiteral(arg, value, type) {
-    if (value === null) {
-        type = "Null";
-    }
-    else 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));
-    }
-    else if (type === "Float") {
-        value = roundToFloat(Number(value));
-    }
-    let raw = type === "String"
-        ? JSON.stringify(value)
-        : type === "Char"
-            ? value === "'"
-                ? "'\\''"
-                : "'" + JSON.stringify(value).slice(1, -1) + "'"
-            : value == null
-                ? "null"
-                : value.toString();
-    if (type === "Long") {
-        raw += "l";
-    }
-    else if (type === "Double") {
-        raw += "d";
-    }
-    else if (type === "Float") {
-        if (prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
-            raw += "f";
-        }
-        else {
-            const match = raw.match(/^(-)?(\d*)\.(\d+)(e\d+)?/);
-            if (match && match[2].length + match[3].length > 9) {
-                for (let l = 9 - match[2].length; l > 0; l--) {
-                    const s = `${match[1] || ""}${match[2]}.${match[3].substring(0, l)}${match[4] || ""}`;
-                    if (value !== roundToFloat(parseFloat(s)))
-                        break;
-                    raw = s;
-                }
-            }
-        }
-    }
-    const { start, end, loc } = arg;
-    return {
-        type: "Literal",
-        value,
-        raw,
-        start,
-        end,
-        loc,
-    };
-}
-function classify(arg) {
-    switch (arg) {
-        case "Number":
-            return { big: false, int: true };
-        case "Long":
-            return { big: true, int: true };
-        case "Float":
-            return { big: false, int: false };
-        case "Double":
-            return { big: true, int: false };
-    }
-    return null;
-}
-function common_arith_types(left, right) {
-    const l = classify(left);
-    if (!l)
-        return null;
-    const r = classify(right);
-    if (!r)
-        return null;
-    if (l.big || r.big) {
-        return l.int && r.int
-            ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
-            : ["Double", (v) => Number(v)];
-    }
-    else {
-        return l.int && r.int
-            ? ["Number", (v) => BigInt.asIntN(32, BigInt(v))]
-            : ["Float", (v) => roundToFloat(Number(v))];
-    }
-}
-function common_bitwise_types(left, right) {
-    if (left === "Boolean" && right === "Boolean") {
-        return ["Boolean", (v) => (v ? true : false)];
-    }
-    const l = classify(left);
-    if (!l)
-        return null;
-    const r = classify(right);
-    if (!r)
+function optimizeNode(istate, node) {
+    if (istate.state.inlining)
         return null;
-    if (!l.int || !r.int)
-        return null;
-    return l.big || r.big
-        ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
-        : ["Number", (v) => Number(BigInt.asIntN(32, BigInt(v)))];
-}
-function plus_types(left, right) {
-    if (left === "String" || right === "String") {
-        // Boolean + String is an error, and
-        // Float/Double + String is legal, but its hard to predict
-        // the way the float will be formatted (and it won't match
-        // what javascript would do by default)
-        if (/Float|Double|Boolean/.test(left + right)) {
-            return null;
-        }
-        return ["String", String];
-    }
-    if (left === "Char" || right === "Char") {
-        if (left === right) {
-            // adding two chars produces a string
-            return ["String", String];
-        }
-        if (/Number|Long/.test(left + right)) {
-            return ["Char", (v) => v];
-        }
-    }
-    return common_arith_types(left, right);
-}
-function shift_mod_types(left, right) {
-    const result = common_bitwise_types(left, right);
-    if (result && result[0] === "Boolean") {
+    if (istate.state.inType) {
         return null;
     }
-    return result;
-}
-function equalsFn(left, right) {
-    const lt = typeof left;
-    const rt = typeof right;
-    return lt === "string" || rt === "string"
-        ? // two string literals will compare unequal, becuase string
-            // equality is object equality.
-            false
-        : (lt === "number" || lt === "bigint") &&
-            (rt === "number" || rt === "bigint")
-            ? // numeric types are compared for value equality
-                left == right
-            : // otherwise types and values must match
-                left === right;
-}
-const operators = {
-    "+": {
-        typeFn: plus_types,
-        valueFn: (left, right) => typeof left === "string" && typeof right !== "string"
-            ? String.fromCharCode(left.charCodeAt(0) + Number(right))
-            : typeof left !== "string" && typeof right === "string"
-                ? String.fromCharCode(right.charCodeAt(0) + Number(left))
-                : left + right,
-    },
-    "-": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left - right,
-    },
-    "*": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left * right,
-    },
-    "/": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left / right,
-    },
-    "%": {
-        typeFn: shift_mod_types,
-        valueFn: (left, right) => left % right,
-    },
-    "&": {
-        typeFn: common_bitwise_types,
-        valueFn: (left, right) => left & right,
-    },
-    "|": {
-        typeFn: common_bitwise_types,
-        valueFn: (left, right) => left | right,
-    },
-    "^": {
-        typeFn: common_bitwise_types,
-        valueFn: (left, right) => left ^ right,
-    },
-    "<<": {
-        typeFn: shift_mod_types,
-        valueFn: (left, right) => typeof right === "bigint"
-            ? left << right
-            : left << right,
-    },
-    ">>": {
-        typeFn: shift_mod_types,
-        valueFn: (left, right) => typeof right === "bigint"
-            ? left >> right
-            : left >> right,
-    },
-    "==": {
-        typeFn: () => ["Boolean", (v) => v],
-        valueFn: equalsFn,
-    },
-    "!=": {
-        typeFn: () => ["Boolean", (v) => v],
-        valueFn: (left, right) => !equalsFn(left, right),
-    },
-    "<=": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left <= right,
-    },
-    ">=": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left >= right,
-    },
-    "<": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left < right,
-    },
-    ">": {
-        typeFn: common_arith_types,
-        valueFn: (left, right) => left > right,
-    },
-    as: null,
-    instanceof: null,
-    has: null,
-};
-function optimizeNode(state, node) {
     switch (node.type) {
-        case "UnaryExpression": {
-            const [arg, type] = getNodeValue(node.argument);
-            if (arg === null)
-                break;
-            switch (node.operator) {
-                case "+":
-                    if (type === "Number" ||
-                        type === "Long" ||
-                        type === "Float" ||
-                        type === "Double" ||
-                        type === "Char" ||
-                        type === "String") {
-                        return arg;
-                    }
-                    break;
-                case "-":
-                    if (type === "Number" ||
-                        type === "Long" ||
-                        type === "Float" ||
-                        type === "Double") {
-                        return replacementLiteral(node, -arg.value, type);
-                    }
-                    break;
-                case "!":
-                case "~":
-                    {
-                        if (type === "Number" || type === "Long") {
-                            return replacementLiteral(node, ~BigInt(arg.value), type);
-                        }
-                        if (type === "Boolean" && node.operator == "!") {
-                            return replacementLiteral(node, !arg.value, type);
-                        }
-                    }
-                    break;
-            }
-            break;
-        }
-        case "BinaryExpression": {
-            const op = operators[node.operator];
-            if (op) {
-                const [left, left_type] = getNodeValue(node.left);
-                const [right, right_type] = getNodeValue(node.right);
-                if (!left || !right)
-                    break;
-                const type = op.typeFn(left_type, right_type);
-                if (!type)
-                    break;
-                const value = op.valueFn(type[1](left.value), type[1](right.value));
-                if (value === null)
-                    break;
-                return replacementLiteral(node, value, type[0]);
-            }
+        case "UpdateExpression":
+            // we only evaluated any subexpressions of the argument.
+            evaluateNode(istate, node.argument);
             break;
-        }
-        case "LogicalExpression": {
-            const [left, left_type] = getNodeValue(node.left);
-            if (!left)
-                break;
-            const falsy = left.value === false ||
-                left.value === null ||
-                ((left_type === "Number" || left_type === "Long") &&
-                    (left.value === 0 || left.value === 0n));
-            if (falsy === (node.operator === "&&" || node.operator === "and")) {
-                return left;
-            }
-            if (left_type !== "Boolean" &&
-                left_type !== "Number" &&
-                left_type !== "Long") {
-                break;
-            }
-            const [right, right_type] = getNodeValue(node.right);
-            if (right && right_type === left_type) {
-                if (left_type === "Boolean" ||
-                    node.operator === "||" ||
-                    node.operator === "or") {
-                    return right;
-                }
-                if (node.operator !== "&&" && node.operator !== "and") {
-                    throw new Error(`Unexpected operator "${node.operator}"`);
-                }
-                return { ...node, type: "BinaryExpression", operator: "&" };
-            }
-            if (left_type === "Boolean") {
-                if (isBooleanExpression(state, node.right)) {
-                    return node.right;
-                }
-            }
+        case "AssignmentExpression": {
+            // we only evaluated any subexpressions of the lhs.
+            const right = istate.stack.pop();
+            evaluateNode(istate, node.left);
+            istate.stack.push(right);
             break;
         }
-        case "FunctionDeclaration":
-            if (node.body && evaluateFunction(state, node, null) !== false) {
-                node.optimizable = true;
+        case "BinaryExpression":
+            if (node.operator === "has" &&
+                node.right.type === "UnaryExpression" &&
+                node.right.operator === ":") {
+                // we skipped this node, so evaluate it now...
+                istate.stack.push(interp_evaluate(istate, node.right));
             }
             break;
     }
-    return null;
+    const before = beforeEvaluate(istate, node);
+    if (before != null)
+        return before;
+    evaluateNode(istate, node);
+    return afterEvaluate(istate, node);
 }
-function evaluateFunction(state, func, args) {
-    if (!func.body || (args && args.length != func.params.length)) {
+function evaluateFunction(istate, func, args) {
+    if (!func.body ||
+        istate.state.inlining ||
+        (args && args.length != func.params.length)) {
         return false;
     }
     const paramValues = args &&
-        Object.fromEntries(func.params.map((p, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(p), args[i]]));
+        Object.fromEntries(func.params.map((p, i) => [
+            (0,external_api_cjs_namespaceObject.variableDeclarationName)(p),
+            args[i],
+        ]));
     let ret = null;
     const body = args ? cloneDeep(func.body) : func.body;
+    const depth = istate.stack.length;
     try {
         traverseAst(body, (node) => {
             switch (node.type) {
@@ -8413,24 +11045,28 @@ function evaluateFunction(state, func, args) {
                         ret = node.argument || null;
                         return null;
                     case "BlockStatement":
-                    case "Literal":
                         return null;
                     case "Identifier":
                         if ((0,external_api_cjs_namespaceObject.hasProperty)(paramValues, node.name)) {
-                            return paramValues[node.name];
+                            istate.stack.push(interp_evaluate(istate, (node = paramValues[node.name])));
+                            return node;
                         }
                     // fall through;
                     default: {
-                        const repl = optimizeNode(state, node);
-                        if (repl && repl.type === "Literal")
+                        const repl = optimizeNode(istate, node) || node;
+                        if (repl.type === "Literal")
                             return repl;
                         throw new Error("Didn't optimize");
                     }
                 }
             });
+        delete istate.state.inlining;
+        istate.stack.length = depth;
         return ret;
     }
     catch (e) {
+        delete istate.state.inlining;
+        istate.stack.length = depth;
         return false;
     }
 }
@@ -8449,51 +11085,22 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     const replace = (node, old) => {
         if (node === false || node === null)
             return node;
+        if (isExpression(node)) {
+            popIstate(istate, old);
+        }
         const rep = state.traverse(node);
         if (rep === false || Array.isArray(rep))
             return rep;
-        return { ...(rep || node), loc: old.loc, start: old.start, end: old.end };
-    };
-    const inPlaceReplacement = (node, obj) => {
-        const { start, end, loc } = node;
-        for (const k of Object.keys(node)) {
-            delete node[k];
-        }
-        if (obj.enumType) {
-            obj = {
-                type: "BinaryExpression",
-                operator: "as",
-                left: { ...obj, start, end, loc },
-                right: { type: "TypeSpecList", ts: [obj.enumType] },
-            };
-        }
-        for (const [k, v] of Object.entries(obj)) {
-            node[k] = v;
-        }
-        node.loc = loc;
-        node.start = start;
-        node.end = end;
-    };
-    const lookupAndReplace = (node) => {
-        const [, objects] = state.lookup(node);
-        if (!objects) {
-            return false;
-        }
-        let obj = getLiteralFromDecls(objects);
-        if (!obj) {
-            return false;
-        }
-        while (obj.type === "BinaryExpression") {
-            if (obj.left.type === "BinaryExpression" && obj.left.operator === "as") {
-                obj = { ...obj, left: obj.left.left };
-            }
-            else {
-                obj = { ...obj, left: { ...obj.left } };
-                break;
-            }
+        const result = {
+            ...(rep || node),
+            loc: old.loc,
+            start: old.start,
+            end: old.end,
+        };
+        if (isExpression(result)) {
+            istate.stack[istate.stack.length - 1].node = result;
         }
-        inPlaceReplacement(node, obj);
-        return true;
+        return result;
     };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
     /*
@@ -8586,48 +11193,14 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             }
         }
     };
+    // use this when optimizing initializer expressions,
+    // outside of any function.
+    const gistate = { state, stack: [] };
+    // use this when type inference is enabled, and we're
+    // inside a function.
+    let istate = gistate;
     state.pre = (node) => {
         switch (node.type) {
-            case "ConditionalExpression":
-            case "IfStatement":
-            case "DoWhileStatement":
-            case "WhileStatement": {
-                const test = (state.traverse(node.test) ||
-                    node.test);
-                const [value, type] = getNodeValue(test);
-                if (value) {
-                    let result = null;
-                    if (type === "Null") {
-                        result = false;
-                    }
-                    else if (type === "Boolean" ||
-                        type === "Number" ||
-                        type === "Long") {
-                        result = !!value.value;
-                    }
-                    if (result !== null) {
-                        node.test = {
-                            type: "Literal",
-                            value: result,
-                            raw: result.toString(),
-                        };
-                        if (node.type === "IfStatement" ||
-                            node.type === "ConditionalExpression") {
-                            return [result ? "consequent" : "alternate"];
-                        }
-                        else if (node.type === "WhileStatement") {
-                            return result === false ? [] : ["body"];
-                        }
-                        else if (node.type === "DoWhileStatement") {
-                            return ["body"];
-                        }
-                        else {
-                            throw new Error("Unexpected Node type");
-                        }
-                    }
-                }
-                return null;
-            }
             case "EnumDeclaration":
                 return [];
             case "ForStatement": {
@@ -8649,13 +11222,14 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 }
                 break;
             case "BinaryExpression":
-                if (node.operator === "has") {
-                    if (node.right.type === "UnaryExpression" &&
-                        node.right.operator === ":") {
-                        // Using `expr has :symbol` doesn't "expose"
-                        // symbol. So skip the right operand.
-                        return ["left"];
-                    }
+                if (node.operator === "has"
+                    ? node.right.type === "UnaryExpression" &&
+                        node.right.operator === ":"
+                    : node.operator === "as") {
+                    // Using `expr has :symbol` doesn't "expose"
+                    // symbol, and the rhs of an "as" isn't an
+                    // expression. In both cases, skip the rhs
+                    return ["left"];
                 }
                 break;
             case "UnaryExpression":
@@ -8695,29 +11269,8 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                         }
                     }
                 }
-                if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.name)) {
-                    if (!lookupAndReplace(node)) {
-                        state.usedByName[node.name] = true;
-                    }
-                }
                 return [];
             }
-            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.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;
@@ -8733,9 +11286,15 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     }
                 }
                 else if (lhs.type === "MemberExpression") {
-                    state.traverse(lhs.object);
-                    if (lhs.computed) {
-                        state.traverse(lhs.property);
+                    const object = state.traverse(lhs.object);
+                    if (object) {
+                        lhs.object = object;
+                    }
+                    if (!(0,external_api_cjs_namespaceObject.isLookupCandidate)(lhs)) {
+                        const property = state.traverse(lhs.property);
+                        if (property) {
+                            lhs.property = property;
+                        }
                     }
                 }
                 return node.type === "AssignmentExpression" ? ["right"] : [];
@@ -8760,6 +11319,23 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     throw new Error(`Nested functions: ${self.fullName} was activated during processing of ${state.currentFunction.fullName}`);
                 }
                 state.currentFunction = self;
+                const is = !state.config?.propagateTypes ||
+                    node.attrs?.attributes?.elements.find((attr) => attr.type == "UnaryExpression" &&
+                        attr.argument.name === "noConstProp")
+                    ? null
+                    : type_flow_buildTypeInfo(state, state.currentFunction);
+                if (is) {
+                    /*
+                     * istate contains a copy of state, but we need the real
+                     * thing, because "state" is captured here.
+                     *
+                     * A better solution will be to separate out a
+                     * "lookup context", which will be a stack, plus a couple
+                     * of fields from state, and then pass that around.
+                     */
+                    is.state = state;
+                    istate = is;
+                }
                 if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
                     let used = false;
                     if (node.id.name == "initialize") {
@@ -8772,7 +11348,15 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                         markFunctionCalled(state, node);
                     }
                 }
+                // We dont want to call evaluateNode on
+                // id, args or returnType
+                return ["body"];
             }
+            case "ClassDeclaration":
+            case "ModuleDeclaration":
+                // We dont want to call evaluateNode on
+                // id, or superClass
+                return ["body"];
         }
         return null;
     };
@@ -8781,18 +11365,25 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         if (locals.node === node) {
             state.localsStack.pop();
         }
-        const opt = optimizeNode(state, node);
-        if (opt) {
-            return replace(opt, node);
+        const opt = optimizeNode(istate, node);
+        if (opt != null) {
+            return opt;
         }
         switch (node.type) {
             case "FunctionDeclaration":
+                if (node.body && evaluateFunction(istate, node, null) !== false) {
+                    node.optimizable = true;
+                }
                 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 || false;
                 delete state.currentFunction.next_info;
                 delete state.currentFunction;
+                if (istate.stack.length) {
+                    throw new Error("Stack was not empty");
+                }
+                istate = gistate;
                 break;
             case "BlockStatement":
                 if (node.body.length === 1 && node.body[0].type === "BlockStatement") {
@@ -8804,74 +11395,32 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     cleanupUnusedVars(state, node);
                 }
                 break;
-            case "ConditionalExpression":
-            case "IfStatement":
-                if (node.test.type === "Literal" &&
-                    typeof node.test.value === "boolean") {
-                    const rep = node.test.value ? node.consequent : node.alternate;
-                    if (!rep)
-                        return false;
-                    return replace(rep, rep);
-                }
-                else if (node.type === "IfStatement") {
-                    if (node.alternate &&
-                        node.alternate.type === "BlockStatement" &&
-                        !node.alternate.body.length) {
-                        delete node.alternate;
-                    }
-                    else {
-                        const call = inlinableSubExpression(node.test);
-                        if (call) {
-                            return replace(optimizeCall(state, call, node), node.test);
-                        }
-                    }
-                }
-                break;
-            case "WhileStatement":
-                if (node.test.type === "Literal" && node.test.value === false) {
-                    return false;
-                }
-                break;
-            case "DoWhileStatement":
-                if (node.test.type === "Literal" && node.test.value === false) {
-                    return node.body;
+            case "IfStatement": {
+                const call = inlinableSubExpression(node.test);
+                if (call) {
+                    return replace(optimizeCall(istate, call, node), node.test);
                 }
                 break;
+            }
             case "ReturnStatement":
                 if (node.argument && node.argument.type === "CallExpression") {
-                    return replace(optimizeCall(state, node.argument, node), node.argument);
+                    return replace(optimizeCall(istate, node.argument, node), node.argument);
                 }
                 break;
-            case "BinaryExpression":
-                if (node.operator === "has" &&
-                    node.right.type === "UnaryExpression" &&
-                    node.right.operator === ":") {
-                    const [, results] = state.lookup(node.left);
-                    if (results &&
-                        results.length === 1 &&
-                        results[0].results.length === 1) {
-                        const obj = results[0].results[0];
-                        if ((obj.type === "ModuleDeclaration" ||
-                            obj.type === "Program" ||
-                            obj.type === "ClassDeclaration") &&
-                            obj.stack) {
-                            const exists = (0,external_api_cjs_namespaceObject.hasProperty)(obj.decls, node.right.argument.name) ||
-                                // This is overkill, since we've already looked up
-                                // node.left, but the actual lookup rules are complicated,
-                                // and embedded within state.lookup; so just defer to that.
-                                state.lookup({
-                                    type: "MemberExpression",
-                                    object: node.left,
-                                    property: node.right.argument,
-                                    computed: false,
-                                })[1];
-                            if (!exists) {
-                                return replace({ type: "Literal", value: false, raw: "false" }, node);
-                            }
-                        }
+            case "Identifier":
+                if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.name)) {
+                    state.usedByName[node.name] = true;
+                }
+                break;
+            case "MemberExpression": {
+                const property = (0,external_api_cjs_namespaceObject.isLookupCandidate)(node);
+                if (property) {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, property.name)) {
+                        state.usedByName[property.name] = true;
                     }
                 }
                 break;
+            }
             case "NewExpression":
                 if (state.currentFunction) {
                     const [, results] = state.lookup(node.callee);
@@ -8884,7 +11433,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 }
                 break;
             case "CallExpression": {
-                return replace(optimizeCall(state, node, null), node);
+                return replace(optimizeCall(istate, node, null), node);
             }
             case "VariableDeclaration": {
                 const locals = topLocals();
@@ -8901,7 +11450,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                             continue;
                         const call = inlinableSubExpression(decl.init);
                         if (call) {
-                            const inlined = replace(optimizeCall(state, call, decl), decl.init);
+                            const inlined = replace(optimizeCall(istate, call, decl), decl.init);
                             if (!inlined)
                                 continue;
                             if (Array.isArray(inlined) || inlined.type != "BlockStatement") {
@@ -8933,7 +11482,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             }
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    return replace(optimizeCall(state, node.expression, node), node.expression);
+                    return replace(optimizeCall(istate, node.expression, node), node.expression);
                 }
                 else if (node.expression.type === "AssignmentExpression") {
                     const call = inlinableSubExpression(node.expression.right);
@@ -8949,7 +11498,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                             ok = !!result;
                         }
                         if (ok) {
-                            return replace(optimizeCall(state, call, node.expression), node.expression.right);
+                            return replace(optimizeCall(istate, call, node.expression), node.expression.right);
                         }
                     }
                 }
@@ -8968,7 +11517,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     node.left.type === "Identifier" &&
                     node.right.type === "Identifier" &&
                     node.left.name === node.right.name) {
-                    return { type: "Literal", value: null, raw: "null" };
+                    return replace({ type: "Literal", value: null, raw: "null" }, node);
                 }
             // fall through;
             case "UpdateExpression":
@@ -9116,7 +11665,8 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     });
     return state.diagnostics;
 }
-function optimizeCall(state, node, context) {
+function optimizeCall(istate, node, context) {
+    const state = istate.state;
     const [name, results] = state.lookupNonlocal(node.callee);
     const callees = results ? findCallees(results) : null;
     if (!callees || !callees.length) {
@@ -9151,7 +11701,7 @@ function optimizeCall(state, node, context) {
             callee.optimizable &&
             !callee.hasOverride &&
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
-            const ret = evaluateFunction(state, callee, node.arguments);
+            const ret = evaluateFunction(istate, callee, node.arguments);
             if (ret) {
                 return ret;
             }
@@ -9620,7 +12170,10 @@ const configOptionsToCheck = [
     "ignoredSourcePaths",
     "checkInvalidSymbols",
     "checkCompilerLookupRules",
+    "checkTypes",
     "sizeBasedPRE",
+    "trustDeclaredTypes",
+    "propagateTypes",
     "extensionVersion",
 ];
 /**
@@ -9680,7 +12233,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
         // 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 && 1672601827382 < opt_time) {
+        if (source_time < opt_time && 1673220499844 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -9707,7 +12260,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.0.45",
+                optimizerVersion: "1.1.0",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));