numtypes 0.0.0

package/dist/transformer/transform/optimize-coercions.js

@@ -0,0 +1,1702 @@
+import * as ts from "typescript";
+const arithmeticOperators = new Set([
+    ts.SyntaxKind.AsteriskAsteriskToken,
+    ts.SyntaxKind.AsteriskToken,
+    ts.SyntaxKind.MinusToken,
+    ts.SyntaxKind.PercentToken,
+    ts.SyntaxKind.PlusToken,
+    ts.SyntaxKind.SlashToken
+]);
+const bitwiseOperators = new Set([
+    ts.SyntaxKind.AmpersandToken,
+    ts.SyntaxKind.BarToken,
+    ts.SyntaxKind.CaretToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken,
+    ts.SyntaxKind.GreaterThanGreaterThanToken,
+    ts.SyntaxKind.LessThanLessThanToken
+]);
+const compoundAssignmentOperators = new Set([
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken
+]);
+export function optimizeCoercions(input) {
+    const optimizedSourceFile = new CoercionOptimizer(input).optimizeSourceFile(input.sourceFile);
+    return new U32ClosureSinker({
+        ...input,
+        sourceFile: optimizedSourceFile
+    }).optimizeSourceFile();
+}
+class CoercionOptimizer {
+    checker;
+    context;
+    factory;
+    generatedCoercions;
+    optimizeTypedArrayElementAccess;
+    typedArrayBoundsFacts = [];
+    capturedMutableSymbols = new Set();
+    constructor(input) {
+        this.checker = input.checker;
+        this.context = input.context;
+        this.factory = input.context.factory;
+        this.generatedCoercions = input.generatedCoercions;
+        this.optimizeTypedArrayElementAccess =
+            input.optimizeTypedArrayElementAccess;
+    }
+    optimizeSourceFile(sourceFile) {
+        const visitor = (node) => {
+            return this.optimizeNodeWithoutFacts(node);
+        };
+        return ts.visitEachChild(sourceFile, visitor, this.context);
+    }
+    optimizeNodeWithoutFacts(node) {
+        if (ts.isFunctionDeclaration(node)) {
+            return this.optimizeFunctionDeclaration(node);
+        }
+        if (ts.isFunctionExpression(node)) {
+            return this.optimizeFunctionExpression(node);
+        }
+        if (ts.isArrowFunction(node)) {
+            return this.optimizeArrowFunction(node);
+        }
+        if (ts.isMethodDeclaration(node)) {
+            return this.optimizeMethodDeclaration(node);
+        }
+        if (ts.isConstructorDeclaration(node)) {
+            return this.optimizeConstructorDeclaration(node);
+        }
+        if (ts.isGetAccessorDeclaration(node)) {
+            return this.optimizeGetAccessorDeclaration(node);
+        }
+        if (ts.isSetAccessorDeclaration(node)) {
+            return this.optimizeSetAccessorDeclaration(node);
+        }
+        if (ts.isClassStaticBlockDeclaration(node)) {
+            return this.factory.updateClassStaticBlockDeclaration(node, this.optimizeBlock(node.body, new Map()));
+        }
+        return ts.visitEachChild(node, (child) => this.optimizeNodeWithoutFacts(child), this.context);
+    }
+    optimizeFunctionDeclaration(node) {
+        return this.withFunctionScope(node, () => this.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, this.optimizeOptionalBlock(node.body)));
+    }
+    optimizeFunctionExpression(node) {
+        return this.withFunctionScope(node, () => this.factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, this.optimizeBlock(node.body, new Map())));
+    }
+    optimizeArrowFunction(node) {
+        return this.withFunctionScope(node, () => {
+            const facts = new Map();
+            const body = ts.isBlock(node.body)
+                ? this.optimizeBlock(node.body, facts)
+                : this.optimizeExpression(node.body, facts).expression;
+            return this.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, body);
+        });
+    }
+    optimizeMethodDeclaration(node) {
+        return this.withFunctionScope(node, () => this.factory.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, this.optimizeOptionalBlock(node.body)));
+    }
+    optimizeConstructorDeclaration(node) {
+        return this.withFunctionScope(node, () => this.factory.updateConstructorDeclaration(node, node.modifiers, node.parameters, this.optimizeOptionalBlock(node.body)));
+    }
+    optimizeGetAccessorDeclaration(node) {
+        return this.withFunctionScope(node, () => this.factory.updateGetAccessorDeclaration(node, node.modifiers, node.name, node.parameters, node.type, this.optimizeOptionalBlock(node.body)));
+    }
+    optimizeSetAccessorDeclaration(node) {
+        return this.withFunctionScope(node, () => this.factory.updateSetAccessorDeclaration(node, node.modifiers, node.name, node.parameters, this.optimizeOptionalBlock(node.body)));
+    }
+    withFunctionScope(node, callback) {
+        const previousCapturedMutableSymbols = this.capturedMutableSymbols;
+        this.capturedMutableSymbols = collectCapturedMutableSymbols(node, this.checker);
+        try {
+            return callback();
+        }
+        finally {
+            this.capturedMutableSymbols = previousCapturedMutableSymbols;
+        }
+    }
+    optimizeOptionalBlock(block) {
+        if (block === undefined) {
+            return undefined;
+        }
+        return this.optimizeBlock(block, new Map());
+    }
+    optimizeBlock(block, facts) {
+        const statements = block.statements.map((statement) => this.optimizeStatement(statement, facts));
+        return this.factory.updateBlock(block, statements);
+    }
+    optimizeStatement(statement, facts) {
+        if (ts.isVariableStatement(statement)) {
+            return this.optimizeVariableStatement(statement, facts);
+        }
+        if (ts.isExpressionStatement(statement)) {
+            const expression = this.optimizeExpression(statement.expression, facts).expression;
+            return this.factory.updateExpressionStatement(statement, expression);
+        }
+        if (ts.isReturnStatement(statement)) {
+            return this.factory.updateReturnStatement(statement, statement.expression === undefined
+                ? undefined
+                : this.optimizeExpression(statement.expression, facts).expression);
+        }
+        if (ts.isIfStatement(statement)) {
+            return this.optimizeIfStatement(statement, facts);
+        }
+        if (ts.isForStatement(statement)) {
+            return this.optimizeForStatement(statement, facts);
+        }
+        if (ts.isWhileStatement(statement)) {
+            return this.optimizeWhileStatement(statement, facts);
+        }
+        if (ts.isDoStatement(statement)) {
+            return this.optimizeDoStatement(statement, facts);
+        }
+        if (ts.isSwitchStatement(statement)) {
+            return this.optimizeSwitchStatement(statement, facts);
+        }
+        if (ts.isTryStatement(statement)) {
+            return this.optimizeTryStatement(statement, facts);
+        }
+        if (ts.isForInStatement(statement)) {
+            return this.optimizeForInStatement(statement, facts);
+        }
+        if (ts.isForOfStatement(statement)) {
+            return this.optimizeForOfStatement(statement, facts);
+        }
+        if (ts.isLabeledStatement(statement)) {
+            return this.factory.updateLabeledStatement(statement, statement.label, this.optimizeStatement(statement.statement, facts));
+        }
+        if (ts.isBlock(statement)) {
+            return this.optimizeBlock(statement, facts);
+        }
+        if (ts.isFunctionDeclaration(statement)) {
+            return this.optimizeFunctionDeclaration(statement);
+        }
+        facts.clear();
+        return ts.visitEachChild(statement, (node) => this.optimizeNodeWithoutFacts(node), this.context);
+    }
+    optimizeVariableStatement(statement, facts) {
+        const declarations = statement.declarationList.declarations.map((declaration) => this.optimizeVariableDeclaration(declaration, facts));
+        return this.factory.updateVariableStatement(statement, statement.modifiers, this.factory.updateVariableDeclarationList(statement.declarationList, declarations));
+    }
+    optimizeVariableDeclaration(declaration, facts) {
+        if (declaration.initializer === undefined) {
+            this.invalidateBindingName(declaration.name, facts);
+            return declaration;
+        }
+        const initializer = this.optimizeExpression(declaration.initializer, facts);
+        this.updateBindingNameFact(declaration.name, initializer.domain, facts);
+        return this.factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, initializer.expression);
+    }
+    optimizeIfStatement(statement, facts) {
+        const expression = this.optimizeExpression(statement.expression, facts).expression;
+        const thenFacts = cloneFacts(facts);
+        const elseFacts = cloneFacts(facts);
+        const thenStatement = this.optimizeStatement(statement.thenStatement, thenFacts);
+        const elseStatement = statement.elseStatement === undefined
+            ? undefined
+            : this.optimizeStatement(statement.elseStatement, elseFacts);
+        const joinedFacts = statement.elseStatement === undefined
+            ? joinFacts(thenFacts, facts)
+            : joinFacts(thenFacts, elseFacts);
+        facts.clear();
+        copyFacts(joinedFacts, facts);
+        return this.factory.updateIfStatement(statement, expression, thenStatement, elseStatement);
+    }
+    optimizeForStatement(statement, facts) {
+        const initializer = statement.initializer === undefined
+            ? undefined
+            : this.optimizeForInitializer(statement.initializer, facts);
+        const condition = statement.condition === undefined
+            ? undefined
+            : this.optimizeExpression(statement.condition, facts).expression;
+        const entryFacts = cloneFacts(facts);
+        const bodyFacts = cloneFacts(entryFacts);
+        const typedArrayBoundsFacts = this.getForLoopTypedArrayBoundsFacts(statement);
+        const optimizedStatement = this.withTypedArrayBoundsFacts(typedArrayBoundsFacts, () => this.optimizeStatement(statement.statement, bodyFacts));
+        const incrementor = statement.incrementor === undefined
+            ? undefined
+            : this.optimizeExpression(statement.incrementor, bodyFacts).expression;
+        const exitFacts = joinFacts(entryFacts, bodyFacts);
+        facts.clear();
+        copyFacts(exitFacts, facts);
+        return this.factory.updateForStatement(statement, initializer, condition, incrementor, optimizedStatement);
+    }
+    optimizeForInitializer(initializer, facts) {
+        if (ts.isVariableDeclarationList(initializer)) {
+            const declarations = initializer.declarations.map((declaration) => this.optimizeVariableDeclaration(declaration, facts));
+            return this.factory.updateVariableDeclarationList(initializer, declarations);
+        }
+        return this.optimizeExpression(initializer, facts).expression;
+    }
+    optimizeWhileStatement(statement, facts) {
+        const expression = this.optimizeExpression(statement.expression, facts).expression;
+        const entryFacts = cloneFacts(facts);
+        const bodyFacts = cloneFacts(entryFacts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const exitFacts = joinFacts(entryFacts, bodyFacts);
+        facts.clear();
+        copyFacts(exitFacts, facts);
+        return this.factory.updateWhileStatement(statement, expression, optimizedStatement);
+    }
+    optimizeDoStatement(statement, facts) {
+        const bodyFacts = cloneFacts(facts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const expression = this.optimizeExpression(statement.expression, bodyFacts).expression;
+        facts.clear();
+        copyFacts(bodyFacts, facts);
+        return this.factory.updateDoStatement(statement, optimizedStatement, expression);
+    }
+    optimizeSwitchStatement(statement, facts) {
+        const expression = this.optimizeExpression(statement.expression, facts).expression;
+        const clauseFacts = [];
+        const clauses = statement.caseBlock.clauses.map((clause) => {
+            const factsForClause = cloneFacts(facts);
+            const optimizedClause = ts.isCaseClause(clause)
+                ? this.optimizeCaseClause(clause, factsForClause)
+                : this.optimizeDefaultClause(clause, factsForClause);
+            clauseFacts.push(factsForClause);
+            return optimizedClause;
+        });
+        const joinedFacts = clauseFacts.length === 0 ? undefined : joinAllFacts(clauseFacts);
+        facts.clear();
+        if (joinedFacts !== undefined) {
+            copyFacts(joinedFacts, facts);
+        }
+        return this.factory.updateSwitchStatement(statement, expression, this.factory.updateCaseBlock(statement.caseBlock, clauses));
+    }
+    optimizeCaseClause(clause, facts) {
+        const expression = this.optimizeExpression(clause.expression, facts).expression;
+        const statements = clause.statements.map((statement) => this.optimizeStatement(statement, facts));
+        return this.factory.updateCaseClause(clause, expression, statements);
+    }
+    optimizeDefaultClause(clause, facts) {
+        const statements = clause.statements.map((statement) => this.optimizeStatement(statement, facts));
+        return this.factory.updateDefaultClause(clause, statements);
+    }
+    optimizeTryStatement(statement, facts) {
+        const tryFacts = cloneFacts(facts);
+        const tryBlock = this.optimizeBlock(statement.tryBlock, tryFacts);
+        let catchClause;
+        let joinedFacts = tryFacts;
+        if (statement.catchClause !== undefined) {
+            const catchFacts = cloneFacts(facts);
+            if (statement.catchClause.variableDeclaration !== undefined) {
+                this.invalidateBindingName(statement.catchClause.variableDeclaration.name, catchFacts);
+            }
+            const catchBlock = this.optimizeBlock(statement.catchClause.block, catchFacts);
+            catchClause = this.factory.updateCatchClause(statement.catchClause, statement.catchClause.variableDeclaration, catchBlock);
+            joinedFacts = joinFacts(tryFacts, catchFacts);
+        }
+        if (statement.finallyBlock !== undefined) {
+            const finallyFacts = cloneFacts(joinedFacts);
+            const finallyBlock = this.optimizeBlock(statement.finallyBlock, finallyFacts);
+            facts.clear();
+            copyFacts(finallyFacts, facts);
+            return this.factory.updateTryStatement(statement, tryBlock, catchClause, finallyBlock);
+        }
+        facts.clear();
+        copyFacts(joinedFacts, facts);
+        return this.factory.updateTryStatement(statement, tryBlock, catchClause, statement.finallyBlock);
+    }
+    optimizeForInStatement(statement, facts) {
+        const initializer = this.optimizeForInitializer(statement.initializer, facts);
+        const expression = this.optimizeExpression(statement.expression, facts).expression;
+        const entryFacts = cloneFacts(facts);
+        const bodyFacts = cloneFacts(entryFacts);
+        this.invalidateForIterationInitializer(initializer, bodyFacts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const exitFacts = joinFacts(entryFacts, bodyFacts);
+        facts.clear();
+        copyFacts(exitFacts, facts);
+        return this.factory.updateForInStatement(statement, initializer, expression, optimizedStatement);
+    }
+    optimizeForOfStatement(statement, facts) {
+        const initializer = this.optimizeForInitializer(statement.initializer, facts);
+        const expression = this.optimizeExpression(statement.expression, facts).expression;
+        const entryFacts = cloneFacts(facts);
+        const bodyFacts = cloneFacts(entryFacts);
+        this.invalidateForIterationInitializer(initializer, bodyFacts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const exitFacts = joinFacts(entryFacts, bodyFacts);
+        facts.clear();
+        copyFacts(exitFacts, facts);
+        return this.factory.updateForOfStatement(statement, statement.awaitModifier, initializer, expression, optimizedStatement);
+    }
+    invalidateForIterationInitializer(initializer, facts) {
+        if (ts.isVariableDeclarationList(initializer)) {
+            for (const declaration of initializer.declarations) {
+                this.invalidateBindingName(declaration.name, facts);
+            }
+            return;
+        }
+        this.invalidateAssignmentTarget(initializer, facts);
+    }
+    optimizeExpression(expression, facts) {
+        if (ts.isParenthesizedExpression(expression)) {
+            const optimizedExpression = this.optimizeExpression(expression.expression, facts);
+            return {
+                domain: optimizedExpression.domain,
+                expression: this.factory.updateParenthesizedExpression(expression, optimizedExpression.expression)
+            };
+        }
+        if (ts.isAsExpression(expression)) {
+            const optimizedExpression = this.optimizeExpression(expression.expression, facts);
+            return {
+                domain: optimizedExpression.domain,
+                expression: this.factory.updateAsExpression(expression, optimizedExpression.expression, expression.type)
+            };
+        }
+        if (ts.isTypeAssertionExpression(expression)) {
+            const optimizedExpression = this.optimizeExpression(expression.expression, facts);
+            return {
+                domain: optimizedExpression.domain,
+                expression: this.factory.updateTypeAssertion(expression, expression.type, optimizedExpression.expression)
+            };
+        }
+        if (ts.isNonNullExpression(expression)) {
+            const optimizedExpression = this.optimizeExpression(expression.expression, facts);
+            return {
+                domain: optimizedExpression.domain,
+                expression: this.factory.updateNonNullExpression(expression, optimizedExpression.expression)
+            };
+        }
+        if (ts.isSatisfiesExpression(expression)) {
+            const optimizedExpression = this.optimizeExpression(expression.expression, facts);
+            return {
+                domain: optimizedExpression.domain,
+                expression: this.factory.updateSatisfiesExpression(expression, optimizedExpression.expression, expression.type)
+            };
+        }
+        if (ts.isIdentifier(expression)) {
+            return {
+                domain: this.getIdentifierFact(expression, facts),
+                expression
+            };
+        }
+        if (ts.isNumericLiteral(expression)) {
+            return {
+                domain: "f64",
+                expression
+            };
+        }
+        if (ts.isPrefixUnaryExpression(expression)) {
+            return this.optimizePrefixUnaryExpression(expression, facts);
+        }
+        if (ts.isPostfixUnaryExpression(expression)) {
+            return this.optimizePostfixUnaryExpression(expression, facts);
+        }
+        if (ts.isBinaryExpression(expression)) {
+            return this.optimizeBinaryExpression(expression, facts);
+        }
+        if (ts.isCallExpression(expression)) {
+            return this.optimizeCallExpression(expression, facts);
+        }
+        if (ts.isConditionalExpression(expression)) {
+            return this.optimizeConditionalExpression(expression, facts);
+        }
+        if (ts.isPropertyAccessExpression(expression)) {
+            const receiver = this.optimizeExpression(expression.expression, facts).expression;
+            this.invalidateReentrySensitiveFacts(facts);
+            return {
+                domain: undefined,
+                expression: this.factory.updatePropertyAccessExpression(expression, receiver, expression.name)
+            };
+        }
+        if (ts.isElementAccessExpression(expression)) {
+            const typedArrayDomain = this.getBoundedTypedArrayElementDomain(expression);
+            const receiver = this.optimizeExpression(expression.expression, facts).expression;
+            const argumentExpression = this.optimizeExpression(expression.argumentExpression, facts).expression;
+            this.invalidateReentrySensitiveFacts(facts);
+            return {
+                domain: typedArrayDomain,
+                expression: this.factory.updateElementAccessExpression(expression, receiver, argumentExpression)
+            };
+        }
+        if (ts.isFunctionExpression(expression)) {
+            return {
+                domain: undefined,
+                expression: this.optimizeFunctionExpression(expression)
+            };
+        }
+        if (ts.isArrowFunction(expression)) {
+            return {
+                domain: undefined,
+                expression: this.optimizeArrowFunction(expression)
+            };
+        }
+        facts.clear();
+        return {
+            domain: undefined,
+            expression: ts.visitEachChild(expression, (node) => this.optimizeNodeWithoutFacts(node), this.context)
+        };
+    }
+    optimizePrefixUnaryExpression(expression, facts) {
+        if (expression.operator === ts.SyntaxKind.PlusPlusToken ||
+            expression.operator === ts.SyntaxKind.MinusMinusToken) {
+            this.invalidateAssignmentTarget(expression.operand, facts);
+            return {
+                domain: undefined,
+                expression
+            };
+        }
+        const operand = this.optimizeExpression(expression.operand, facts);
+        if (expression.operator === ts.SyntaxKind.PlusToken) {
+            if (operand.domain === "f64" &&
+                this.generatedCoercions.isGeneratedCoercion(expression, "f64")) {
+                return operand;
+            }
+            return {
+                domain: "f64",
+                expression: this.generatedCoercions.preserveGeneratedCoercion(expression, this.factory.updatePrefixUnaryExpression(expression, operand.expression))
+            };
+        }
+        if (expression.operator === ts.SyntaxKind.MinusToken &&
+            operand.domain === "f64") {
+            return {
+                domain: "f64",
+                expression: this.factory.updatePrefixUnaryExpression(expression, operand.expression)
+            };
+        }
+        return {
+            domain: undefined,
+            expression: this.factory.updatePrefixUnaryExpression(expression, operand.expression)
+        };
+    }
+    optimizePostfixUnaryExpression(expression, facts) {
+        this.invalidateAssignmentTarget(expression.operand, facts);
+        return {
+            domain: undefined,
+            expression
+        };
+    }
+    optimizeBinaryExpression(expression, facts) {
+        if (expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            return this.optimizeAssignmentExpression(expression, facts);
+        }
+        if (isCompoundAssignmentOperator(expression.operatorToken.kind)) {
+            const left = ts.isIdentifier(expression.left)
+                ? this.optimizeExpression(expression.left, facts).expression
+                : expression.left;
+            if (!ts.isIdentifier(expression.left)) {
+                facts.clear();
+            }
+            const right = this.optimizeExpression(expression.right, facts).expression;
+            this.invalidateAssignmentTarget(expression.left, facts);
+            facts.clear();
+            return {
+                domain: undefined,
+                expression: this.factory.updateBinaryExpression(expression, left, expression.operatorToken, right)
+            };
+        }
+        const coercionDomain = getBinaryCoercionDomain(expression);
+        const isBitwiseExpression = bitwiseOperators.has(expression.operatorToken.kind);
+        const left = this.optimizeExpression(expression.left, facts);
+        const right = this.optimizeExpression(expression.right, facts);
+        if (coercionDomain !== undefined) {
+            if (this.generatedCoercions.isGeneratedCoercion(expression, coercionDomain) &&
+                canElideCoercion(left.expression, left.domain, coercionDomain, this.generatedCoercions)) {
+                return {
+                    domain: coercionDomain,
+                    expression: left.expression
+                };
+            }
+            return {
+                domain: coercionDomain,
+                expression: this.generatedCoercions.preserveGeneratedCoercion(expression, this.factory.updateBinaryExpression(expression, left.expression, expression.operatorToken, right.expression))
+            };
+        }
+        return {
+            domain: this.getBinaryExpressionDomain(expression.operatorToken.kind, left.domain, right.domain),
+            expression: this.factory.updateBinaryExpression(expression, isBitwiseExpression
+                ? stripIntegerCoercion(left.expression, this.generatedCoercions)
+                : left.expression, expression.operatorToken, isBitwiseExpression
+                ? stripIntegerCoercion(right.expression, this.generatedCoercions)
+                : right.expression)
+        };
+    }
+    optimizeAssignmentExpression(expression, facts) {
+        if (!ts.isIdentifier(expression.left)) {
+            this.evaluateAssignmentTarget(expression.left, facts);
+        }
+        const right = this.optimizeExpression(expression.right, facts);
+        this.updateAssignmentTargetFact(expression.left, right.domain, facts);
+        return {
+            domain: right.domain,
+            expression: this.factory.updateBinaryExpression(expression, expression.left, expression.operatorToken, right.expression)
+        };
+    }
+    evaluateAssignmentTarget(target, facts) {
+        if (ts.isIdentifier(target)) {
+            return;
+        }
+        if (ts.isParenthesizedExpression(target)) {
+            this.evaluateAssignmentTarget(target.expression, facts);
+            return;
+        }
+        if (ts.isElementAccessExpression(target)) {
+            this.optimizeExpression(target.expression, facts);
+            this.optimizeExpression(target.argumentExpression, facts);
+            return;
+        }
+        if (ts.isPropertyAccessExpression(target)) {
+            this.optimizeExpression(target.expression, facts);
+            return;
+        }
+        facts.clear();
+    }
+    optimizeCallExpression(expression, facts) {
+        const mathFroundArgument = getMathFroundArgument(expression, this.checker);
+        if (mathFroundArgument !== undefined) {
+            const optimizedArgument = this.optimizeExpression(mathFroundArgument, facts);
+            if (optimizedArgument.domain === "f32" &&
+                this.generatedCoercions.isGeneratedCoercion(expression, "f32")) {
+                return optimizedArgument;
+            }
+            return {
+                domain: "f32",
+                expression: this.generatedCoercions.preserveGeneratedCoercion(expression, this.factory.updateCallExpression(expression, expression.expression, expression.typeArguments, [optimizedArgument.expression]))
+            };
+        }
+        const mathImulArguments = getMathImulArguments(expression, this.checker);
+        if (mathImulArguments !== undefined) {
+            const left = this.optimizeExpression(mathImulArguments[0], facts);
+            const right = this.optimizeExpression(mathImulArguments[1], facts);
+            return {
+                domain: "i32",
+                expression: this.factory.updateCallExpression(expression, expression.expression, expression.typeArguments, [
+                    stripIntegerCoercion(left.expression, this.generatedCoercions),
+                    stripIntegerCoercion(right.expression, this.generatedCoercions)
+                ])
+            };
+        }
+        const callExpression = this.optimizeExpression(expression.expression, facts).expression;
+        const argumentsArray = expression.arguments.map((argument) => this.optimizeExpression(argument, facts).expression);
+        this.invalidateAfterUnknownCall(expression, facts);
+        return {
+            domain: undefined,
+            expression: this.factory.updateCallExpression(expression, callExpression, expression.typeArguments, argumentsArray)
+        };
+    }
+    optimizeConditionalExpression(expression, facts) {
+        const condition = this.optimizeExpression(expression.condition, facts).expression;
+        const thenFacts = cloneFacts(facts);
+        const elseFacts = cloneFacts(facts);
+        const whenTrue = this.optimizeExpression(expression.whenTrue, thenFacts);
+        const whenFalse = this.optimizeExpression(expression.whenFalse, elseFacts);
+        const joinedFacts = joinFacts(thenFacts, elseFacts);
+        facts.clear();
+        copyFacts(joinedFacts, facts);
+        return {
+            domain: whenTrue.domain !== undefined && whenTrue.domain === whenFalse.domain
+                ? whenTrue.domain
+                : undefined,
+            expression: this.factory.updateConditionalExpression(expression, condition, expression.questionToken, whenTrue.expression, expression.colonToken, whenFalse.expression)
+        };
+    }
+    withTypedArrayBoundsFacts(facts, callback) {
+        if (facts.length === 0) {
+            return callback();
+        }
+        const previousFacts = this.typedArrayBoundsFacts;
+        this.typedArrayBoundsFacts = [...previousFacts, ...facts];
+        try {
+            return callback();
+        }
+        finally {
+            this.typedArrayBoundsFacts = previousFacts;
+        }
+    }
+    getForLoopTypedArrayBoundsFacts(statement) {
+        if (!this.optimizeTypedArrayElementAccess ||
+            statement.condition === undefined ||
+            statement.incrementor === undefined) {
+            return [];
+        }
+        const indexSymbol = getForLoopIndexSymbol(statement.initializer, this.checker);
+        if (indexSymbol === undefined ||
+            !isSupportedForLoopIncrementor(statement.incrementor, indexSymbol, this.checker)) {
+            return [];
+        }
+        const boundsFacts = getTypedArrayBoundsFactsFromCondition(statement.condition, indexSymbol, this.checker);
+        if (boundsFacts.length === 0) {
+            return [];
+        }
+        const protectedSymbols = new Set([
+            indexSymbol,
+            ...boundsFacts.map((fact) => fact.arraySymbol)
+        ]);
+        return statementWritesAnySymbol(statement.statement, protectedSymbols, this.checker)
+            ? []
+            : boundsFacts;
+    }
+    getBoundedTypedArrayElementDomain(expression) {
+        if (!this.optimizeTypedArrayElementAccess) {
+            return undefined;
+        }
+        const receiverSymbol = ts.isIdentifier(expression.expression)
+            ? this.checker.getSymbolAtLocation(expression.expression)
+            : undefined;
+        if (receiverSymbol === undefined) {
+            return undefined;
+        }
+        for (const fact of this.typedArrayBoundsFacts) {
+            if (fact.arraySymbol !== receiverSymbol) {
+                continue;
+            }
+            const offset = getIndexOffset(expression.argumentExpression, fact.indexSymbol, this.checker);
+            if (offset !== undefined && offset <= fact.maxOffset) {
+                return fact.domain;
+            }
+        }
+        return undefined;
+    }
+    getBinaryExpressionDomain(operator, leftDomain, rightDomain) {
+        if (leftDomain === "f64" &&
+            rightDomain === "f64" &&
+            arithmeticOperators.has(operator)) {
+            return "f64";
+        }
+        if (bitwiseOperators.has(operator)) {
+            return operator === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken
+                ? "u32"
+                : "i32";
+        }
+        return undefined;
+    }
+    getIdentifierFact(identifier, facts) {
+        const symbol = this.checker.getSymbolAtLocation(identifier);
+        return symbol === undefined ? undefined : facts.get(symbol);
+    }
+    updateBindingNameFact(name, domain, facts) {
+        if (ts.isIdentifier(name)) {
+            this.updateIdentifierFact(name, domain, facts);
+            return;
+        }
+        this.invalidateBindingName(name, facts);
+    }
+    updateAssignmentTargetFact(target, domain, facts) {
+        if (ts.isIdentifier(target)) {
+            this.updateIdentifierFact(target, domain, facts);
+            return;
+        }
+        this.invalidateAssignmentTarget(target, facts);
+        this.invalidateReentrySensitiveFacts(facts);
+    }
+    updateIdentifierFact(identifier, domain, facts) {
+        const symbol = this.checker.getSymbolAtLocation(identifier);
+        if (symbol === undefined) {
+            return;
+        }
+        if (domain === undefined) {
+            facts.delete(symbol);
+            return;
+        }
+        facts.set(symbol, domain);
+    }
+    invalidateBindingName(name, facts) {
+        if (ts.isIdentifier(name)) {
+            this.updateIdentifierFact(name, undefined, facts);
+            return;
+        }
+        for (const element of name.elements) {
+            if (ts.isBindingElement(element)) {
+                this.invalidateBindingName(element.name, facts);
+            }
+        }
+    }
+    invalidateAssignmentTarget(target, facts) {
+        if (ts.isIdentifier(target)) {
+            this.updateIdentifierFact(target, undefined, facts);
+            return;
+        }
+        if (ts.isParenthesizedExpression(target)) {
+            this.invalidateAssignmentTarget(target.expression, facts);
+            return;
+        }
+        if (ts.isElementAccessExpression(target)) {
+            this.optimizeExpression(target.expression, facts);
+            this.optimizeExpression(target.argumentExpression, facts);
+            this.invalidateReentrySensitiveFacts(facts);
+            return;
+        }
+        if (ts.isPropertyAccessExpression(target)) {
+            this.optimizeExpression(target.expression, facts);
+            this.invalidateReentrySensitiveFacts(facts);
+        }
+    }
+    invalidateAfterUnknownCall(expression, facts) {
+        if (ts.isIdentifier(expression.expression) &&
+            expression.expression.text === "eval") {
+            facts.clear();
+            return;
+        }
+        this.invalidateReentrySensitiveFacts(facts);
+    }
+    invalidateReentrySensitiveFacts(facts) {
+        for (const symbol of this.capturedMutableSymbols) {
+            facts.delete(symbol);
+        }
+    }
+}
+class U32ClosureSinker {
+    checker;
+    context;
+    factory;
+    generatedCoercions;
+    sourceFile;
+    constructor(input) {
+        this.checker = input.checker;
+        this.context = input.context;
+        this.factory = input.context.factory;
+        this.generatedCoercions = input.generatedCoercions;
+        this.sourceFile = input.sourceFile;
+    }
+    optimizeSourceFile() {
+        return ts.visitEachChild(this.sourceFile, (node) => this.optimizeNodeWithoutFacts(node), this.context);
+    }
+    optimizeNodeWithoutFacts(node) {
+        if (ts.isFunctionDeclaration(node)) {
+            return this.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, this.optimizeOptionalBlock(node.body));
+        }
+        if (ts.isFunctionExpression(node)) {
+            return this.factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, this.optimizeBlock(node.body, new Map()));
+        }
+        if (ts.isArrowFunction(node)) {
+            const facts = new Map();
+            const body = ts.isBlock(node.body)
+                ? this.optimizeBlock(node.body, facts)
+                : this.optimizeExpression(node.body, facts, "value").expression;
+            return this.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, body);
+        }
+        if (ts.isMethodDeclaration(node)) {
+            return this.factory.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, this.optimizeOptionalBlock(node.body));
+        }
+        if (ts.isConstructorDeclaration(node)) {
+            return this.factory.updateConstructorDeclaration(node, node.modifiers, node.parameters, this.optimizeOptionalBlock(node.body));
+        }
+        if (ts.isGetAccessorDeclaration(node)) {
+            return this.factory.updateGetAccessorDeclaration(node, node.modifiers, node.name, node.parameters, node.type, this.optimizeOptionalBlock(node.body));
+        }
+        if (ts.isSetAccessorDeclaration(node)) {
+            return this.factory.updateSetAccessorDeclaration(node, node.modifiers, node.name, node.parameters, this.optimizeOptionalBlock(node.body));
+        }
+        if (ts.isClassStaticBlockDeclaration(node)) {
+            return this.factory.updateClassStaticBlockDeclaration(node, this.optimizeBlock(node.body, new Map()));
+        }
+        return ts.visitEachChild(node, (child) => this.optimizeNodeWithoutFacts(child), this.context);
+    }
+    optimizeOptionalBlock(block) {
+        if (block === undefined) {
+            return undefined;
+        }
+        return this.optimizeBlock(block, new Map());
+    }
+    optimizeBlock(block, facts) {
+        const statements = block.statements.map((statement) => this.optimizeStatement(statement, facts));
+        return this.factory.updateBlock(block, statements);
+    }
+    optimizeStatement(statement, facts) {
+        if (ts.isVariableStatement(statement)) {
+            const declarations = statement.declarationList.declarations.map((declaration) => this.optimizeVariableDeclaration(declaration, facts));
+            return this.factory.updateVariableStatement(statement, statement.modifiers, this.factory.updateVariableDeclarationList(statement.declarationList, declarations));
+        }
+        if (ts.isExpressionStatement(statement)) {
+            const expression = this.optimizeExpression(statement.expression, facts, "value").expression;
+            return this.factory.updateExpressionStatement(statement, expression);
+        }
+        if (ts.isReturnStatement(statement)) {
+            return this.factory.updateReturnStatement(statement, statement.expression === undefined
+                ? undefined
+                : this.optimizeExpression(statement.expression, facts, "value")
+                    .expression);
+        }
+        if (ts.isIfStatement(statement)) {
+            return this.optimizeIfStatement(statement, facts);
+        }
+        if (ts.isForStatement(statement)) {
+            return this.optimizeForStatement(statement, facts);
+        }
+        if (ts.isWhileStatement(statement)) {
+            return this.optimizeWhileStatement(statement, facts);
+        }
+        if (ts.isDoStatement(statement)) {
+            return this.optimizeDoStatement(statement, facts);
+        }
+        if (ts.isBlock(statement)) {
+            return this.optimizeBlock(statement, facts);
+        }
+        if (ts.isFunctionDeclaration(statement)) {
+            return this.optimizeNodeWithoutFacts(statement);
+        }
+        facts.clear();
+        return ts.visitEachChild(statement, (node) => this.optimizeNodeWithoutFacts(node), this.context);
+    }
+    optimizeVariableDeclaration(declaration, facts) {
+        if (declaration.initializer === undefined) {
+            this.deleteBindingState(declaration.name, facts);
+            return declaration;
+        }
+        const sinkedInitializer = this.trySinkU32Closure(declaration.initializer, facts);
+        const initializerResult = sinkedInitializer === undefined
+            ? this.optimizeExpression(declaration.initializer, facts, "value")
+            : {
+                expression: sinkedInitializer,
+                state: "raw"
+            };
+        const storedState = sinkedInitializer === undefined
+            ? getClosedU32StorageState(initializerResult.expression)
+            : "raw";
+        this.updateBindingState(declaration.name, storedState, facts);
+        return this.factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, initializerResult.expression);
+    }
+    optimizeIfStatement(statement, facts) {
+        const expression = this.optimizeExpression(statement.expression, facts, "value").expression;
+        const thenFacts = cloneU32Facts(facts);
+        const elseFacts = cloneU32Facts(facts);
+        const thenStatement = this.optimizeStatement(statement.thenStatement, thenFacts);
+        const elseStatement = statement.elseStatement === undefined
+            ? undefined
+            : this.optimizeStatement(statement.elseStatement, elseFacts);
+        const joinedFacts = statement.elseStatement === undefined
+            ? joinU32Facts(facts, thenFacts)
+            : joinU32Facts(thenFacts, elseFacts);
+        facts.clear();
+        copyU32Facts(joinedFacts, facts);
+        return this.factory.updateIfStatement(statement, expression, thenStatement, elseStatement);
+    }
+    optimizeForStatement(statement, facts) {
+        const initializer = statement.initializer === undefined
+            ? undefined
+            : this.optimizeForInitializer(statement.initializer, facts);
+        const condition = statement.condition === undefined
+            ? undefined
+            : this.optimizeExpression(statement.condition, facts, "value").expression;
+        const entryFacts = cloneU32Facts(facts);
+        const bodyFacts = cloneU32Facts(entryFacts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const incrementor = statement.incrementor === undefined
+            ? undefined
+            : this.optimizeExpression(statement.incrementor, bodyFacts, "value")
+                .expression;
+        const exitFacts = joinU32Facts(entryFacts, bodyFacts);
+        facts.clear();
+        copyU32Facts(exitFacts, facts);
+        return this.factory.updateForStatement(statement, initializer, condition, incrementor, optimizedStatement);
+    }
+    optimizeForInitializer(initializer, facts) {
+        if (ts.isVariableDeclarationList(initializer)) {
+            const declarations = initializer.declarations.map((declaration) => this.optimizeVariableDeclaration(declaration, facts));
+            return this.factory.updateVariableDeclarationList(initializer, declarations);
+        }
+        return this.optimizeExpression(initializer, facts, "value").expression;
+    }
+    optimizeWhileStatement(statement, facts) {
+        const expression = this.optimizeExpression(statement.expression, facts, "value").expression;
+        const entryFacts = cloneU32Facts(facts);
+        const bodyFacts = cloneU32Facts(entryFacts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const exitFacts = joinU32Facts(entryFacts, bodyFacts);
+        facts.clear();
+        copyU32Facts(exitFacts, facts);
+        return this.factory.updateWhileStatement(statement, expression, optimizedStatement);
+    }
+    optimizeDoStatement(statement, facts) {
+        const bodyFacts = cloneU32Facts(facts);
+        const optimizedStatement = this.optimizeStatement(statement.statement, bodyFacts);
+        const expression = this.optimizeExpression(statement.expression, bodyFacts, "value").expression;
+        facts.clear();
+        copyU32Facts(bodyFacts, facts);
+        return this.factory.updateDoStatement(statement, optimizedStatement, expression);
+    }
+    optimizeExpression(expression, facts, expressionContext) {
+        if (ts.isParenthesizedExpression(expression)) {
+            const optimizedExpression = this.optimizeExpression(expression.expression, facts, expressionContext);
+            return {
+                expression: this.factory.updateParenthesizedExpression(expression, optimizedExpression.expression),
+                state: optimizedExpression.state
+            };
+        }
+        if (ts.isIdentifier(expression)) {
+            const state = this.getIdentifierState(expression, facts);
+            if (state === "raw" && expressionContext === "value") {
+                return {
+                    expression: createU32Coercion(this.factory, expression),
+                    state: "closed"
+                };
+            }
+            return {
+                expression,
+                state
+            };
+        }
+        if (ts.isNumericLiteral(expression)) {
+            return {
+                expression,
+                state: isNumericLiteralClosedInDomain(expression, "u32")
+                    ? "closed"
+                    : undefined
+            };
+        }
+        if (ts.isBinaryExpression(expression)) {
+            return this.optimizeBinaryExpression(expression, facts, expressionContext);
+        }
+        if (ts.isCallExpression(expression)) {
+            const mathImulArguments = getMathImulArguments(expression, this.checker);
+            if (mathImulArguments !== undefined) {
+                const left = this.optimizeExpression(mathImulArguments[0], facts, "low32").expression;
+                const right = this.optimizeExpression(mathImulArguments[1], facts, "low32").expression;
+                return {
+                    expression: this.factory.updateCallExpression(expression, expression.expression, expression.typeArguments, [left, right]),
+                    state: "raw"
+                };
+            }
+            const callExpression = this.optimizeExpression(expression.expression, facts, "value").expression;
+            const argumentsArray = expression.arguments.map((argument) => this.optimizeExpression(argument, facts, "value").expression);
+            facts.clear();
+            return {
+                expression: this.factory.updateCallExpression(expression, callExpression, expression.typeArguments, argumentsArray),
+                state: undefined
+            };
+        }
+        if (ts.isConditionalExpression(expression)) {
+            const condition = this.optimizeExpression(expression.condition, facts, "value").expression;
+            const thenFacts = cloneU32Facts(facts);
+            const elseFacts = cloneU32Facts(facts);
+            const whenTrue = this.optimizeExpression(expression.whenTrue, thenFacts, expressionContext);
+            const whenFalse = this.optimizeExpression(expression.whenFalse, elseFacts, expressionContext);
+            const joinedFacts = joinU32Facts(thenFacts, elseFacts);
+            facts.clear();
+            copyU32Facts(joinedFacts, facts);
+            return {
+                expression: this.factory.updateConditionalExpression(expression, condition, expression.questionToken, whenTrue.expression, expression.colonToken, whenFalse.expression),
+                state: whenTrue.state === whenFalse.state ? whenTrue.state : undefined
+            };
+        }
+        if (ts.isPropertyAccessExpression(expression)) {
+            const receiver = this.optimizeExpression(expression.expression, facts, "value").expression;
+            return {
+                expression: this.factory.updatePropertyAccessExpression(expression, receiver, expression.name),
+                state: undefined
+            };
+        }
+        if (ts.isElementAccessExpression(expression)) {
+            const receiver = this.optimizeExpression(expression.expression, facts, "value").expression;
+            const argumentExpression = this.optimizeExpression(expression.argumentExpression, facts, "value").expression;
+            return {
+                expression: this.factory.updateElementAccessExpression(expression, receiver, argumentExpression),
+                state: undefined
+            };
+        }
+        if (ts.isFunctionExpression(expression)) {
+            return {
+                expression: this.optimizeNodeWithoutFacts(expression),
+                state: undefined
+            };
+        }
+        if (ts.isArrowFunction(expression)) {
+            return {
+                expression: this.optimizeNodeWithoutFacts(expression),
+                state: undefined
+            };
+        }
+        return {
+            expression: ts.visitEachChild(expression, (node) => this.optimizeNodeWithoutFacts(node), this.context),
+            state: undefined
+        };
+    }
+    optimizeBinaryExpression(expression, facts, expressionContext) {
+        if (expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            return this.optimizeAssignmentExpression(expression, facts);
+        }
+        const coercionDomain = getBinaryCoercionDomain(expression);
+        if (coercionDomain === "u32") {
+            const left = this.optimizeExpression(expression.left, facts, "low32");
+            if (expressionContext === "low32" &&
+                this.generatedCoercions.isGeneratedCoercion(expression, "u32")) {
+                return {
+                    expression: left.expression,
+                    state: left.state
+                };
+            }
+            return {
+                expression: this.generatedCoercions.preserveGeneratedCoercion(expression, this.factory.updateBinaryExpression(expression, left.expression, expression.operatorToken, expression.right)),
+                state: "closed"
+            };
+        }
+        if (bitwiseOperators.has(expression.operatorToken.kind)) {
+            const left = this.optimizeExpression(expression.left, facts, "low32").expression;
+            const right = this.optimizeExpression(expression.right, facts, "low32").expression;
+            return {
+                expression: this.factory.updateBinaryExpression(expression, left, expression.operatorToken, right),
+                state: expression.operatorToken.kind ===
+                    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken
+                    ? "closed"
+                    : "raw"
+            };
+        }
+        const left = this.optimizeExpression(expression.left, facts, "value").expression;
+        const right = this.optimizeExpression(expression.right, facts, "value").expression;
+        return {
+            expression: this.factory.updateBinaryExpression(expression, left, expression.operatorToken, right),
+            state: undefined
+        };
+    }
+    optimizeAssignmentExpression(expression, facts) {
+        const targetSymbol = ts.isIdentifier(expression.left)
+            ? this.checker.getSymbolAtLocation(expression.left)
+            : undefined;
+        const sinkedRight = targetSymbol !== undefined && facts.has(targetSymbol)
+            ? this.trySinkU32Closure(expression.right, facts)
+            : undefined;
+        if (!ts.isIdentifier(expression.left)) {
+            this.optimizeAssignmentTarget(expression.left, facts);
+        }
+        const right = sinkedRight === undefined
+            ? this.optimizeExpression(expression.right, facts, "value")
+            : {
+                expression: sinkedRight,
+                state: "raw"
+            };
+        if (targetSymbol !== undefined) {
+            const storedState = sinkedRight === undefined
+                ? getClosedU32StorageState(right.expression)
+                : "raw";
+            this.updateIdentifierState(targetSymbol, storedState, facts);
+        }
+        else {
+            facts.clear();
+        }
+        return {
+            expression: this.factory.updateBinaryExpression(expression, expression.left, expression.operatorToken, right.expression),
+            state: right.state
+        };
+    }
+    optimizeAssignmentTarget(target, facts) {
+        if (ts.isParenthesizedExpression(target)) {
+            this.optimizeAssignmentTarget(target.expression, facts);
+            return;
+        }
+        if (ts.isElementAccessExpression(target)) {
+            this.optimizeExpression(target.expression, facts, "value");
+            this.optimizeExpression(target.argumentExpression, facts, "value");
+            return;
+        }
+        if (ts.isPropertyAccessExpression(target)) {
+            this.optimizeExpression(target.expression, facts, "value");
+            return;
+        }
+        facts.clear();
+    }
+    trySinkU32Closure(expression, facts) {
+        const unwrappedExpression = unwrapParentheses(expression);
+        if (!ts.isBinaryExpression(unwrappedExpression)) {
+            return undefined;
+        }
+        if (getBinaryCoercionDomain(unwrappedExpression) !== "u32") {
+            return undefined;
+        }
+        if (!this.generatedCoercions.isGeneratedCoercion(unwrappedExpression, "u32")) {
+            return undefined;
+        }
+        if (!this.isSinkableLow32Expression(unwrappedExpression.left, facts)) {
+            return undefined;
+        }
+        return this.optimizeExpression(unwrappedExpression.left, facts, "low32").expression;
+    }
+    isSinkableLow32Expression(expression, facts) {
+        const unwrappedExpression = unwrapParentheses(expression);
+        if (ts.isIdentifier(unwrappedExpression)) {
+            const symbol = this.checker.getSymbolAtLocation(unwrappedExpression);
+            return symbol !== undefined && facts.has(symbol);
+        }
+        if (ts.isNumericLiteral(unwrappedExpression)) {
+            return isNumericLiteralClosedInDomain(unwrappedExpression, "u32");
+        }
+        if (ts.isBinaryExpression(unwrappedExpression)) {
+            return bitwiseOperators.has(unwrappedExpression.operatorToken.kind);
+        }
+        return (ts.isCallExpression(unwrappedExpression) &&
+            getMathImulArguments(unwrappedExpression, this.checker) !== undefined);
+    }
+    getIdentifierState(identifier, facts) {
+        const symbol = this.checker.getSymbolAtLocation(identifier);
+        return symbol === undefined ? undefined : facts.get(symbol);
+    }
+    updateBindingState(name, state, facts) {
+        if (ts.isIdentifier(name)) {
+            const symbol = this.checker.getSymbolAtLocation(name);
+            if (symbol !== undefined) {
+                this.updateIdentifierState(symbol, state, facts);
+            }
+            return;
+        }
+        this.deleteBindingState(name, facts);
+    }
+    updateIdentifierState(symbol, state, facts) {
+        if (state === undefined) {
+            facts.delete(symbol);
+            return;
+        }
+        facts.set(symbol, state);
+    }
+    deleteBindingState(name, facts) {
+        if (ts.isIdentifier(name)) {
+            const symbol = this.checker.getSymbolAtLocation(name);
+            if (symbol !== undefined) {
+                facts.delete(symbol);
+            }
+            return;
+        }
+        for (const element of name.elements) {
+            if (ts.isBindingElement(element)) {
+                this.deleteBindingState(element.name, facts);
+            }
+        }
+    }
+}
+function getBinaryCoercionDomain(expression) {
+    if (!isZeroLiteral(expression.right)) {
+        return undefined;
+    }
+    if (expression.operatorToken.kind === ts.SyntaxKind.BarToken) {
+        return "i32";
+    }
+    if (expression.operatorToken.kind ===
+        ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
+        return "u32";
+    }
+    return undefined;
+}
+function createU32Coercion(factory, expression) {
+    return factory.createBinaryExpression(expression, factory.createToken(ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken), factory.createNumericLiteral(0));
+}
+function getClosedU32StorageState(expression) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    if (ts.isNumericLiteral(unwrappedExpression)) {
+        return isNumericLiteralClosedInDomain(unwrappedExpression, "u32")
+            ? "closed"
+            : undefined;
+    }
+    if (!ts.isBinaryExpression(unwrappedExpression)) {
+        return undefined;
+    }
+    return getBinaryCoercionDomain(unwrappedExpression) === "u32"
+        ? "closed"
+        : undefined;
+}
+function unwrapParentheses(expression) {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+function cloneU32Facts(facts) {
+    return new Map(facts);
+}
+function copyU32Facts(source, target) {
+    for (const [symbol, state] of source) {
+        target.set(symbol, state);
+    }
+}
+function joinU32Facts(left, right) {
+    const joinedFacts = new Map();
+    for (const [symbol, leftState] of left) {
+        const rightState = right.get(symbol);
+        if (rightState === undefined) {
+            continue;
+        }
+        joinedFacts.set(symbol, leftState === "raw" || rightState === "raw" ? "raw" : "closed");
+    }
+    return joinedFacts;
+}
+function isZeroLiteral(expression) {
+    return ts.isNumericLiteral(expression) && expression.text === "0";
+}
+function canElideCoercion(expression, expressionDomain, coercionDomain, generatedCoercions) {
+    return (expressionDomain === coercionDomain ||
+        isNumericLiteralClosedInDomain(expression, coercionDomain) ||
+        (coercionDomain === "u32" &&
+            isU32ClosedProducerExpression(expression, generatedCoercions)));
+}
+function isU32ClosedProducerExpression(expression, generatedCoercions) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    if (!ts.isBinaryExpression(unwrappedExpression)) {
+        return false;
+    }
+    if (getBinaryCoercionDomain(unwrappedExpression) === "u32" &&
+        generatedCoercions.isGeneratedCoercion(unwrappedExpression, "u32")) {
+        return true;
+    }
+    if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.AmpersandToken &&
+        (isNonNegativeInt31Mask(unwrappedExpression.left) ||
+            isNonNegativeInt31Mask(unwrappedExpression.right))) {
+        return true;
+    }
+    if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.PercentToken &&
+        isPositiveIntegerLiteral(unwrappedExpression.right) &&
+        isU32ClosedProducerExpression(unwrappedExpression.left, generatedCoercions)) {
+        return true;
+    }
+    return false;
+}
+function isNonNegativeInt31Mask(expression) {
+    const value = getNumericLiteralValue(expression);
+    return (value !== undefined &&
+        Number.isInteger(value) &&
+        value >= 0 &&
+        value <= 0x7fffffff);
+}
+function isPositiveIntegerLiteral(expression) {
+    const value = getNumericLiteralValue(expression);
+    return value !== undefined && Number.isInteger(value) && value > 0;
+}
+function getNumericLiteralValue(expression) {
+    const literal = getUnwrappedNumericLiteral(expression);
+    return literal === undefined ? undefined : Number(literal.text);
+}
+function stripIntegerCoercion(expression, generatedCoercions) {
+    if (ts.isParenthesizedExpression(expression)) {
+        const strippedExpression = stripIntegerCoercion(expression.expression, generatedCoercions);
+        if (strippedExpression === expression.expression) {
+            return expression;
+        }
+        return strippedExpression;
+    }
+    if (!ts.isBinaryExpression(expression)) {
+        return expression;
+    }
+    const coercionDomain = getBinaryCoercionDomain(expression);
+    if (coercionDomain !== "i32" && coercionDomain !== "u32") {
+        return expression;
+    }
+    if (!generatedCoercions.isGeneratedCoercion(expression, coercionDomain)) {
+        return expression;
+    }
+    return expression.left;
+}
+function isNumericLiteralClosedInDomain(expression, domain) {
+    const literal = getUnwrappedNumericLiteral(expression);
+    if (literal === undefined) {
+        return false;
+    }
+    const value = Number(literal.text);
+    if (!Number.isInteger(value)) {
+        return false;
+    }
+    switch (domain) {
+        case "f32":
+            return Math.fround(value) === value;
+        case "f64":
+            return true;
+        case "i32":
+            return value >= -2147483648 && value <= 2147483647;
+        case "u32":
+            return value >= 0 && value <= 4294967295;
+    }
+}
+function getUnwrappedNumericLiteral(expression) {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current)) {
+        current = current.expression;
+    }
+    return ts.isNumericLiteral(current) ? current : undefined;
+}
+function getMathFroundArgument(expression, checker) {
+    if (expression.arguments.length !== 1) {
+        return undefined;
+    }
+    const argument = expression.arguments[0];
+    if (argument === undefined) {
+        return undefined;
+    }
+    if (!ts.isPropertyAccessExpression(expression.expression)) {
+        return undefined;
+    }
+    const isMathFround = ts.isIdentifier(expression.expression.expression) &&
+        isMathIntrinsicIdentifier(expression.expression.expression, checker) &&
+        expression.expression.expression.text === "Math" &&
+        expression.expression.name.text === "fround";
+    return isMathFround ? argument : undefined;
+}
+function getMathImulArguments(expression, checker) {
+    if (expression.arguments.length !== 2) {
+        return undefined;
+    }
+    const left = expression.arguments[0];
+    const right = expression.arguments[1];
+    if (left === undefined || right === undefined) {
+        return undefined;
+    }
+    if (!ts.isPropertyAccessExpression(expression.expression)) {
+        return undefined;
+    }
+    const isMathImul = ts.isIdentifier(expression.expression.expression) &&
+        isMathIntrinsicIdentifier(expression.expression.expression, checker) &&
+        expression.expression.expression.text === "Math" &&
+        expression.expression.name.text === "imul";
+    return isMathImul ? [left, right] : undefined;
+}
+function isMathIntrinsicIdentifier(identifier, checker) {
+    const symbol = checker.getSymbolAtLocation(identifier);
+    if (symbol === undefined) {
+        return identifier.pos < 0;
+    }
+    const declarations = symbol.declarations;
+    if (declarations === undefined || declarations.length === 0) {
+        return false;
+    }
+    return declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile);
+}
+function isCompoundAssignmentOperator(operator) {
+    return compoundAssignmentOperators.has(operator);
+}
+function getForLoopIndexSymbol(initializer, checker) {
+    if (initializer === undefined) {
+        return undefined;
+    }
+    if (ts.isVariableDeclarationList(initializer)) {
+        if (initializer.declarations.length !== 1) {
+            return undefined;
+        }
+        const declaration = initializer.declarations[0];
+        if (declaration === undefined ||
+            !ts.isIdentifier(declaration.name) ||
+            declaration.initializer === undefined ||
+            !isZeroNumberExpression(declaration.initializer)) {
+            return undefined;
+        }
+        return checker.getSymbolAtLocation(declaration.name);
+    }
+    if (ts.isBinaryExpression(initializer) &&
+        initializer.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(initializer.left) &&
+        isZeroNumberExpression(initializer.right)) {
+        return checker.getSymbolAtLocation(initializer.left);
+    }
+    return undefined;
+}
+function isSupportedForLoopIncrementor(incrementor, indexSymbol, checker) {
+    const expression = unwrapParentheses(incrementor);
+    if ((ts.isPrefixUnaryExpression(expression) ||
+        ts.isPostfixUnaryExpression(expression)) &&
+        expression.operator === ts.SyntaxKind.PlusPlusToken) {
+        return isIdentifierForSymbol(expression.operand, indexSymbol, checker);
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken &&
+        isIdentifierForSymbol(expression.left, indexSymbol, checker)) {
+        return isPositiveIntegerExpression(expression.right);
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        isIdentifierForSymbol(expression.left, indexSymbol, checker)) {
+        return isIndexPlusPositiveInteger(expression.right, indexSymbol, checker);
+    }
+    return false;
+}
+function getTypedArrayBoundsFactsFromCondition(condition, indexSymbol, checker) {
+    const expression = unwrapParentheses(condition);
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        return [
+            ...getTypedArrayBoundsFactsFromCondition(expression.left, indexSymbol, checker),
+            ...getTypedArrayBoundsFactsFromCondition(expression.right, indexSymbol, checker)
+        ];
+    }
+    const fact = getTypedArrayBoundsFactFromComparison(expression, indexSymbol, checker);
+    return fact === undefined ? [] : [fact];
+}
+function getTypedArrayBoundsFactFromComparison(expression, indexSymbol, checker) {
+    if (!ts.isBinaryExpression(expression)) {
+        return undefined;
+    }
+    if (expression.operatorToken.kind === ts.SyntaxKind.LessThanToken) {
+        return createTypedArrayBoundsFact(expression.left, expression.right, indexSymbol, checker);
+    }
+    if (expression.operatorToken.kind === ts.SyntaxKind.GreaterThanToken) {
+        return createTypedArrayBoundsFact(expression.right, expression.left, indexSymbol, checker);
+    }
+    return undefined;
+}
+function createTypedArrayBoundsFact(indexExpression, lengthExpression, indexSymbol, checker) {
+    const maxOffset = getIndexOffset(indexExpression, indexSymbol, checker);
+    const lengthAccess = getTypedArrayLengthAccess(lengthExpression, checker);
+    if (maxOffset === undefined || lengthAccess === undefined) {
+        return undefined;
+    }
+    return {
+        arraySymbol: lengthAccess.arraySymbol,
+        domain: lengthAccess.domain,
+        indexSymbol,
+        maxOffset
+    };
+}
+function getTypedArrayLengthAccess(expression, checker) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    if (!ts.isPropertyAccessExpression(unwrappedExpression) ||
+        unwrappedExpression.name.text !== "length" ||
+        !ts.isIdentifier(unwrappedExpression.expression)) {
+        return undefined;
+    }
+    const domain = getTypedArrayElementDomain(checker.getTypeAtLocation(unwrappedExpression.expression));
+    const arraySymbol = checker.getSymbolAtLocation(unwrappedExpression.expression);
+    if (domain === undefined || arraySymbol === undefined) {
+        return undefined;
+    }
+    return {
+        arraySymbol,
+        domain
+    };
+}
+function getTypedArrayElementDomain(type) {
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    const name = symbol === undefined ? undefined : symbol.getName();
+    if (name === undefined) {
+        return undefined;
+    }
+    switch (name) {
+        case "Int8Array":
+        case "Int16Array":
+        case "Int32Array":
+            return "i32";
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Uint16Array":
+        case "Uint32Array":
+            return "u32";
+        case "Float32Array":
+            return "f32";
+        case "Float64Array":
+            return "f64";
+        default:
+            return undefined;
+    }
+}
+function getIndexOffset(expression, indexSymbol, checker) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    if (isIdentifierForSymbol(unwrappedExpression, indexSymbol, checker)) {
+        return 0;
+    }
+    if (ts.isBinaryExpression(unwrappedExpression) &&
+        unwrappedExpression.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+        if (isIdentifierForSymbol(unwrappedExpression.left, indexSymbol, checker)) {
+            return getNonNegativeIntegerLiteralValue(unwrappedExpression.right);
+        }
+        if (isIdentifierForSymbol(unwrappedExpression.right, indexSymbol, checker)) {
+            return getNonNegativeIntegerLiteralValue(unwrappedExpression.left);
+        }
+    }
+    return undefined;
+}
+function isIndexPlusPositiveInteger(expression, indexSymbol, checker) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    return (ts.isBinaryExpression(unwrappedExpression) &&
+        unwrappedExpression.operatorToken.kind === ts.SyntaxKind.PlusToken &&
+        ((isIdentifierForSymbol(unwrappedExpression.left, indexSymbol, checker) &&
+            isPositiveIntegerExpression(unwrappedExpression.right)) ||
+            (isIdentifierForSymbol(unwrappedExpression.right, indexSymbol, checker) &&
+                isPositiveIntegerExpression(unwrappedExpression.left))));
+}
+function statementWritesAnySymbol(node, symbols, checker) {
+    let writes = false;
+    const visit = (current) => {
+        if (writes || isNestedRuntimeBoundary(current)) {
+            return;
+        }
+        if (ts.isBinaryExpression(current) && isAssignmentOperator(current.operatorToken.kind)) {
+            if (assignmentTargetWritesAnySymbol(current.left, symbols, checker)) {
+                writes = true;
+                return;
+            }
+        }
+        if ((ts.isPrefixUnaryExpression(current) ||
+            ts.isPostfixUnaryExpression(current)) &&
+            (current.operator === ts.SyntaxKind.PlusPlusToken ||
+                current.operator === ts.SyntaxKind.MinusMinusToken) &&
+            assignmentTargetWritesAnySymbol(current.operand, symbols, checker)) {
+            writes = true;
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+    return writes;
+}
+function assignmentTargetWritesAnySymbol(expression, symbols, checker) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    if (ts.isIdentifier(unwrappedExpression)) {
+        const symbol = checker.getSymbolAtLocation(unwrappedExpression);
+        return symbol !== undefined && symbols.has(symbol);
+    }
+    if (ts.isArrayLiteralExpression(unwrappedExpression)) {
+        return unwrappedExpression.elements.some((element) => assignmentTargetWritesAnySymbol(element, symbols, checker));
+    }
+    if (ts.isObjectLiteralExpression(unwrappedExpression)) {
+        return unwrappedExpression.properties.some((property) => {
+            if (ts.isShorthandPropertyAssignment(property)) {
+                const symbol = checker.getSymbolAtLocation(property.name);
+                return symbol !== undefined && symbols.has(symbol);
+            }
+            return (ts.isPropertyAssignment(property) &&
+                assignmentTargetWritesAnySymbol(property.initializer, symbols, checker));
+        });
+    }
+    return false;
+}
+function isAssignmentOperator(operator) {
+    return (operator === ts.SyntaxKind.EqualsToken ||
+        isCompoundAssignmentOperator(operator));
+}
+function isIdentifierForSymbol(expression, symbol, checker) {
+    return (ts.isIdentifier(unwrapParentheses(expression)) &&
+        checker.getSymbolAtLocation(unwrapParentheses(expression)) === symbol);
+}
+function isZeroNumberExpression(expression) {
+    return getNonNegativeIntegerLiteralValue(expression) === 0;
+}
+function isPositiveIntegerExpression(expression) {
+    const value = getNonNegativeIntegerLiteralValue(expression);
+    return value !== undefined && value > 0;
+}
+function getNonNegativeIntegerLiteralValue(expression) {
+    const unwrappedExpression = unwrapParentheses(expression);
+    if (!ts.isNumericLiteral(unwrappedExpression)) {
+        return undefined;
+    }
+    const value = Number(unwrappedExpression.text);
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function cloneFacts(facts) {
+    return new Map(facts);
+}
+function copyFacts(source, target) {
+    for (const [symbol, domain] of source) {
+        target.set(symbol, domain);
+    }
+}
+function joinFacts(left, right) {
+    const joinedFacts = new Map();
+    for (const [symbol, leftDomain] of left) {
+        const rightDomain = right.get(symbol);
+        if (rightDomain === leftDomain) {
+            joinedFacts.set(symbol, leftDomain);
+        }
+    }
+    return joinedFacts;
+}
+function joinAllFacts(factMaps) {
+    const [firstFactMap, ...remainingFactMaps] = factMaps;
+    if (firstFactMap === undefined) {
+        return new Map();
+    }
+    let joinedFacts = cloneFacts(firstFactMap);
+    for (const factMap of remainingFactMaps) {
+        joinedFacts = joinFacts(joinedFacts, factMap);
+    }
+    return joinedFacts;
+}
+function collectCapturedMutableSymbols(node, checker) {
+    const mutableLocalSymbols = new Set();
+    collectParameterSymbols(node, checker, mutableLocalSymbols);
+    if (node.body !== undefined) {
+        collectMutableLocalSymbols(node.body, checker, mutableLocalSymbols);
+    }
+    if (mutableLocalSymbols.size === 0 || node.body === undefined) {
+        return new Set();
+    }
+    const capturedSymbols = new Set();
+    collectCapturesFromNestedFunctions(node.body, checker, mutableLocalSymbols, capturedSymbols);
+    return capturedSymbols;
+}
+function collectParameterSymbols(node, checker, symbols) {
+    for (const parameter of node.parameters) {
+        collectBindingNameSymbols(parameter.name, checker, symbols);
+    }
+}
+function collectMutableLocalSymbols(node, checker, symbols) {
+    const visit = (current) => {
+        if (isNestedRuntimeBoundary(current)) {
+            return;
+        }
+        if (ts.isVariableDeclarationList(current)) {
+            if ((ts.getCombinedNodeFlags(current) & ts.NodeFlags.Const) === 0) {
+                for (const declaration of current.declarations) {
+                    collectBindingNameSymbols(declaration.name, checker, symbols);
+                }
+            }
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    ts.forEachChild(node, visit);
+}
+function collectCapturesFromNestedFunctions(node, checker, mutableLocalSymbols, capturedSymbols) {
+    const visit = (current) => {
+        if (isFunctionLikeWithBody(current)) {
+            const body = current.body;
+            if (body !== undefined) {
+                collectIdentifierCaptures(body, checker, mutableLocalSymbols, capturedSymbols);
+            }
+            return;
+        }
+        if (ts.isClassLike(current)) {
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    ts.forEachChild(node, visit);
+}
+function collectIdentifierCaptures(node, checker, mutableLocalSymbols, capturedSymbols) {
+    const visit = (current) => {
+        if (ts.isTypeNode(current)) {
+            return;
+        }
+        if (ts.isIdentifier(current)) {
+            const symbol = checker.getSymbolAtLocation(current);
+            if (symbol !== undefined && mutableLocalSymbols.has(symbol)) {
+                capturedSymbols.add(symbol);
+            }
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+}
+function collectBindingNameSymbols(name, checker, symbols) {
+    if (ts.isIdentifier(name)) {
+        const symbol = checker.getSymbolAtLocation(name);
+        if (symbol !== undefined) {
+            symbols.add(symbol);
+        }
+        return;
+    }
+    for (const element of name.elements) {
+        if (ts.isBindingElement(element)) {
+            collectBindingNameSymbols(element.name, checker, symbols);
+        }
+    }
+}
+function isNestedRuntimeBoundary(node) {
+    return isFunctionLikeWithBody(node) || ts.isClassLike(node);
+}
+function isFunctionLikeWithBody(node) {
+    return ((ts.isArrowFunction(node) ||
+        ts.isConstructorDeclaration(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node)) &&
+        node.body !== undefined);
+}
+//# sourceMappingURL=optimize-coercions.js.map