numtypes 0.0.0

package/dist/transformer/analyze/get-expression-domain.js

@@ -0,0 +1,804 @@
+import * as ts from "typescript";
+import { isNumericTypeDomain } from "./type-domain.js";
+import { createDiagnostic } from "../diagnostics.js";
+import { getTransparentDomainWrapperExpression, isTransparentDomainWrapper } from "../ast.js";
+import { sortNumericDomains } from "../domains.js";
+import { supportsBitwiseOperator } from "../operators.js";
+import { getTypeDomain } from "./type-domain.js";
+import { getNumtypeBindingName } from "../symbols.js";
+const unaryArithmeticOperatorBySyntaxKind = new Map([
+    [ts.SyntaxKind.PlusToken, "+"],
+    [ts.SyntaxKind.MinusToken, "-"]
+]);
+const binaryArithmeticOperatorBySyntaxKind = new Map([
+    [ts.SyntaxKind.PlusToken, "+"],
+    [ts.SyntaxKind.MinusToken, "-"],
+    [ts.SyntaxKind.AsteriskToken, "*"],
+    [ts.SyntaxKind.SlashToken, "/"],
+    [ts.SyntaxKind.PercentToken, "%"],
+    [ts.SyntaxKind.AsteriskAsteriskToken, "**"]
+]);
+const integerBitwiseOperatorBySyntaxKind = new Map([
+    [ts.SyntaxKind.AmpersandToken, "&"],
+    [ts.SyntaxKind.BarToken, "|"],
+    [ts.SyntaxKind.CaretToken, "^"],
+    [ts.SyntaxKind.LessThanLessThanToken, "<<"],
+    [ts.SyntaxKind.GreaterThanGreaterThanToken, ">>"],
+    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, ">>>"]
+]);
+const compoundArithmeticOperatorBySyntaxKind = new Map([
+    [ts.SyntaxKind.PlusEqualsToken, "+"],
+    [ts.SyntaxKind.MinusEqualsToken, "-"],
+    [ts.SyntaxKind.AsteriskEqualsToken, "*"],
+    [ts.SyntaxKind.SlashEqualsToken, "/"],
+    [ts.SyntaxKind.PercentEqualsToken, "%"],
+    [ts.SyntaxKind.AsteriskAsteriskEqualsToken, "**"]
+]);
+const compoundBitwiseOperatorBySyntaxKind = new Map([
+    [ts.SyntaxKind.AmpersandEqualsToken, "&"],
+    [ts.SyntaxKind.BarEqualsToken, "|"],
+    [ts.SyntaxKind.CaretEqualsToken, "^"],
+    [ts.SyntaxKind.LessThanLessThanEqualsToken, "<<"],
+    [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken, ">>"],
+    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, ">>>"]
+]);
+export function createExpressionDomainCache() {
+    return new WeakMap();
+}
+export function getExpressionDomain(input) {
+    return analyzeExpression({
+        ...input,
+        cache: input.cache ?? createExpressionDomainCache()
+    });
+}
+function analyzeExpression(input) {
+    const expression = skipParentheses(input.expression);
+    const cachedResult = getCachedResult(input.cache, expression, input.contextualDomain);
+    if (cachedResult !== undefined) {
+        return cachedResult;
+    }
+    const result = analyzeExpressionUncached({
+        ...input,
+        expression
+    });
+    setCachedResult(input.cache, expression, input.contextualDomain, result);
+    return result;
+}
+function analyzeExpressionUncached(input) {
+    const expression = input.expression;
+    if (isContextualNumericLiteral(expression, input.contextualDomain)) {
+        return createExpressionResult({
+            diagnostics: [],
+            domain: input.contextualDomain,
+            reason: "contextual-literal",
+            requiresClosure: true
+        });
+    }
+    if (isNumericLiteralLike(expression)) {
+        return createExpressionResult({
+            diagnostics: [],
+            domain: "plain-number",
+            reason: "literal",
+            requiresClosure: false
+        });
+    }
+    if (isTransparentDomainWrapper(expression)) {
+        return analyzeExpression({
+            cache: input.cache,
+            checker: input.checker,
+            contextualDomain: input.contextualDomain,
+            expression: getTransparentDomainWrapperExpression(expression),
+            symbols: input.symbols
+        });
+    }
+    if (ts.isCallExpression(expression)) {
+        return analyzeCallExpression(input, expression);
+    }
+    if (ts.isPrefixUnaryExpression(expression)) {
+        const updateResult = analyzeUpdateExpression(input, expression);
+        if (updateResult !== undefined) {
+            return updateResult;
+        }
+        return analyzePrefixUnaryExpression(input, expression);
+    }
+    if (ts.isPostfixUnaryExpression(expression)) {
+        const updateResult = analyzeUpdateExpression(input, expression);
+        if (updateResult !== undefined) {
+            return updateResult;
+        }
+    }
+    if (ts.isBinaryExpression(expression)) {
+        return analyzeBinaryExpression(input, expression);
+    }
+    if (ts.isConditionalExpression(expression)) {
+        return analyzeConditionalExpression(input, expression);
+    }
+    return analyzeExpressionType(input, expression);
+}
+function analyzeUpdateExpression(input, expression) {
+    const operator = expression.operator;
+    if (!isUpdateOperator(operator)) {
+        return undefined;
+    }
+    const operand = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.operand,
+        symbols: input.symbols
+    });
+    const unionOperationDiagnostic = getUnsupportedUnionOperationDiagnostic(expression, getUpdateOperatorVerb(operator), operand);
+    if (unionOperationDiagnostic !== undefined) {
+        return createExpressionResult({
+            diagnostics: [...operand.diagnostics, unionOperationDiagnostic],
+            domain: "unknown",
+            hasNonNumericUnionMembers: operand.hasNonNumericUnionMembers,
+            reason: "unknown",
+            requiresClosure: false,
+            unionDomains: operand.unionDomains
+        });
+    }
+    if (!isNumericTypeDomain(operand.domain)) {
+        return createExpressionResult({
+            diagnostics: operand.diagnostics,
+            domain: operand.domain,
+            hasNonNumericUnionMembers: operand.hasNonNumericUnionMembers,
+            reason: operand.reason,
+            requiresClosure: false,
+            unionDomains: operand.unionDomains
+        });
+    }
+    return createExpressionResult({
+        diagnostics: operand.diagnostics,
+        domain: operand.domain,
+        reason: "operator",
+        requiresClosure: true
+    });
+}
+function analyzeCallExpression(input, expression) {
+    const binding = input.symbols.getBindingForCastCallee(expression.expression);
+    if (binding === undefined) {
+        return analyzeExpressionType(input, expression);
+    }
+    if (binding.isTypeOnly) {
+        return createExpressionResult({
+            diagnostics: [
+                createDiagnostic("NUMTYPES_UNKNOWN_SYMBOL", `cannot use type-only import '${getNumtypeBindingName(binding)}' as a numtypes cast function`, getDiagnosticLocation(expression.expression))
+            ],
+            domain: "unknown",
+            reason: "unknown",
+            requiresClosure: false
+        });
+    }
+    const argumentDiagnostics = expression.arguments.flatMap((argument) => analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: argument,
+        symbols: input.symbols
+    }).diagnostics);
+    const castCallDiagnostic = getCastCallMisuseDiagnostic(expression, binding);
+    if (castCallDiagnostic !== undefined) {
+        return createExpressionResult({
+            diagnostics: [...argumentDiagnostics, castCallDiagnostic],
+            domain: "unknown",
+            reason: "unknown",
+            requiresClosure: false
+        });
+    }
+    return createExpressionResult({
+        diagnostics: argumentDiagnostics,
+        domain: binding.domain,
+        reason: "cast-call",
+        requiresClosure: true
+    });
+}
+function getCastCallMisuseDiagnostic(expression, binding) {
+    const bindingName = getNumtypeBindingName(binding);
+    if (expression.questionDotToken !== undefined ||
+        hasOptionalPropertyAccessCallee(expression.expression) ||
+        expression.typeArguments !== undefined) {
+        return createDiagnostic("NUMTYPES_ERASED_CAST_MISUSE", `numtypes cast function '${bindingName}' must be called directly as ${bindingName}(value)`, getDiagnosticLocation(expression.expression));
+    }
+    if (expression.arguments.length !== 1) {
+        return createDiagnostic("NUMTYPES_ERASED_CAST_MISUSE", `numtypes cast function '${bindingName}' must be called with exactly one argument`, getDiagnosticLocation(expression.expression));
+    }
+    const argument = expression.arguments[0];
+    if (argument !== undefined && ts.isSpreadElement(argument)) {
+        return createDiagnostic("NUMTYPES_ERASED_CAST_MISUSE", `numtypes cast function '${bindingName}' must be called directly as ${bindingName}(value)`, getDiagnosticLocation(expression.expression));
+    }
+    return undefined;
+}
+function hasOptionalPropertyAccessCallee(expression) {
+    return (ts.isPropertyAccessExpression(expression) &&
+        expression.questionDotToken !== undefined);
+}
+function analyzePrefixUnaryExpression(input, expression) {
+    const operator = getUnaryArithmeticOperator(expression.operator);
+    if (operator === undefined) {
+        return analyzeExpressionType(input, expression);
+    }
+    const operand = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.operand,
+        symbols: input.symbols
+    });
+    const unionOperationDiagnostic = getUnsupportedUnionOperationDiagnostic(expression, getUnaryOperatorVerb(operator), operand);
+    if (unionOperationDiagnostic !== undefined) {
+        return createExpressionResult({
+            diagnostics: [...operand.diagnostics, unionOperationDiagnostic],
+            domain: "unknown",
+            hasNonNumericUnionMembers: operand.hasNonNumericUnionMembers,
+            reason: "unknown",
+            requiresClosure: false,
+            unionDomains: operand.unionDomains
+        });
+    }
+    if (!isNumericTypeDomain(operand.domain)) {
+        return createExpressionResult({
+            diagnostics: operand.diagnostics,
+            domain: operand.domain,
+            hasNonNumericUnionMembers: operand.hasNonNumericUnionMembers,
+            reason: operand.reason,
+            requiresClosure: false,
+            unionDomains: operand.unionDomains
+        });
+    }
+    return createExpressionResult({
+        diagnostics: operand.diagnostics,
+        domain: operand.domain,
+        reason: "operator",
+        requiresClosure: true
+    });
+}
+function analyzeBinaryExpression(input, expression) {
+    const arithmeticOperator = getBinaryArithmeticOperator(expression.operatorToken.kind);
+    if (arithmeticOperator !== undefined) {
+        return analyzeBinaryOperation(input, expression, {
+            kind: "binary-arithmetic",
+            operator: arithmeticOperator
+        });
+    }
+    const bitwiseOperator = getIntegerBitwiseOperator(expression.operatorToken.kind);
+    if (bitwiseOperator !== undefined) {
+        return analyzeBinaryOperation(input, expression, {
+            kind: "bitwise",
+            operator: bitwiseOperator
+        });
+    }
+    const compoundArithmeticOperator = getCompoundArithmeticOperator(expression.operatorToken.kind);
+    if (compoundArithmeticOperator !== undefined) {
+        return analyzeCompoundAssignmentExpression(input, expression);
+    }
+    const compoundBitwiseOperator = getCompoundBitwiseOperator(expression.operatorToken.kind);
+    if (compoundBitwiseOperator !== undefined) {
+        return analyzeCompoundAssignmentExpression(input, expression);
+    }
+    return analyzeExpressionType(input, expression);
+}
+function analyzeCompoundAssignmentExpression(input, expression) {
+    const left = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.left,
+        symbols: input.symbols
+    });
+    const right = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.right,
+        symbols: input.symbols
+    });
+    const unionDomains = getMergedExpressionResultDomains([left, right]);
+    const hasNonNumericUnionMembers = left.hasNonNumericUnionMembers === true ||
+        right.hasNonNumericUnionMembers === true;
+    if (!isNumericTypeDomain(left.domain) &&
+        !isNumericTypeDomain(right.domain) &&
+        unionDomains === undefined) {
+        return analyzeExpressionType(input, expression);
+    }
+    return createExpressionResult({
+        diagnostics: [
+            ...left.diagnostics,
+            ...right.diagnostics,
+            createDiagnostic("NUMTYPES_UNSUPPORTED_COMPOUND_ASSIGNMENT", `cannot use compound assignment '${getCompoundAssignmentText(expression.operatorToken.kind)}' with numtypes values; use an explicit checked assignment`, getDiagnosticLocation(expression))
+        ],
+        domain: "unknown",
+        hasNonNumericUnionMembers,
+        reason: "unknown",
+        requiresClosure: false,
+        unionDomains
+    });
+}
+function analyzeConditionalExpression(input, expression) {
+    const condition = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.condition,
+        symbols: input.symbols
+    });
+    const trueWithoutContext = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.whenTrue,
+        symbols: input.symbols
+    });
+    const falseWithoutContext = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.whenFalse,
+        symbols: input.symbols
+    });
+    const contextualDomain = input.contextualDomain ??
+        getConditionalBranchContextualDomain(trueWithoutContext.domain, falseWithoutContext.domain);
+    const whenTrue = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        contextualDomain,
+        expression: expression.whenTrue,
+        symbols: input.symbols
+    });
+    const whenFalse = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        contextualDomain,
+        expression: expression.whenFalse,
+        symbols: input.symbols
+    });
+    const numericUnion = getConditionalResultUnion(whenTrue, whenFalse);
+    const diagnostics = [
+        ...condition.diagnostics,
+        ...whenTrue.diagnostics,
+        ...whenFalse.diagnostics
+    ];
+    const domainError = input.contextualDomain === undefined
+        ? getConditionalDomainErrorDiagnostic(expression, whenTrue, whenFalse)
+        : undefined;
+    if (domainError !== undefined) {
+        return createExpressionResult({
+            diagnostics: [...diagnostics, domainError],
+            domain: "unknown",
+            reason: "unknown",
+            requiresClosure: false,
+            hasNonNumericUnionMembers: numericUnion?.hasNonNumericMembers,
+            unionDomains: numericUnion?.domains
+        });
+    }
+    const domain = getConditionalResultDomain(whenTrue.domain, whenFalse.domain, contextualDomain);
+    return createExpressionResult({
+        diagnostics,
+        domain,
+        reason: domain === "unknown" ? "unknown" : "operator",
+        requiresClosure: isNumericTypeDomain(domain) || numericUnion !== undefined,
+        hasNonNumericUnionMembers: numericUnion?.hasNonNumericMembers,
+        unionDomains: numericUnion?.domains
+    });
+}
+function getConditionalDomainErrorDiagnostic(expression, whenTrue, whenFalse) {
+    if (isNumericTypeDomain(whenTrue.domain) && isNumericTypeDomain(whenFalse.domain)) {
+        if (whenTrue.domain !== whenFalse.domain) {
+            return undefined;
+        }
+        return undefined;
+    }
+    if (isNumericTypeDomain(whenTrue.domain) && whenFalse.domain === "plain-number") {
+        return createDiagnostic("NUMTYPES_IMPLICIT_NUMBER", `cannot select ${whenTrue.domain} and number without explicit cast`, getDiagnosticLocation(expression));
+    }
+    if (whenTrue.domain === "plain-number" && isNumericTypeDomain(whenFalse.domain)) {
+        return createDiagnostic("NUMTYPES_IMPLICIT_NUMBER", `cannot select number and ${whenFalse.domain} without explicit cast`, getDiagnosticLocation(expression));
+    }
+    const trueUnionCandidate = getExpressionNumericUnionCandidate(whenTrue);
+    const falseUnionCandidate = getExpressionNumericUnionCandidate(whenFalse);
+    if (trueUnionCandidate?.isUnion === true &&
+        whenFalse.domain === "plain-number") {
+        return createDiagnostic("NUMTYPES_IMPLICIT_NUMBER", `cannot select union containing ${trueUnionCandidate.domains.join(" | ")} and number without explicit cast`, getDiagnosticLocation(expression));
+    }
+    if (whenTrue.domain === "plain-number" &&
+        falseUnionCandidate?.isUnion === true) {
+        return createDiagnostic("NUMTYPES_IMPLICIT_NUMBER", `cannot select number and union containing ${falseUnionCandidate.domains.join(" | ")} without explicit cast`, getDiagnosticLocation(expression));
+    }
+    return undefined;
+}
+function getConditionalResultUnion(whenTrue, whenFalse) {
+    const trueCandidate = getExpressionNumericUnionCandidate(whenTrue);
+    const falseCandidate = getExpressionNumericUnionCandidate(whenFalse);
+    if (trueCandidate === undefined && falseCandidate === undefined) {
+        return undefined;
+    }
+    if (trueCandidate === undefined) {
+        if (whenTrue.domain === "plain-number") {
+            return undefined;
+        }
+        return {
+            domains: falseCandidate?.domains ?? [],
+            hasNonNumericMembers: true,
+            isUnion: true
+        };
+    }
+    if (falseCandidate === undefined) {
+        if (whenFalse.domain === "plain-number") {
+            return undefined;
+        }
+        return {
+            domains: trueCandidate.domains,
+            hasNonNumericMembers: true,
+            isUnion: true
+        };
+    }
+    const domains = new Set([
+        ...trueCandidate.domains,
+        ...falseCandidate.domains
+    ]);
+    const hasNonNumericMembers = trueCandidate.hasNonNumericMembers ||
+        falseCandidate.hasNonNumericMembers;
+    const isUnion = trueCandidate.isUnion ||
+        falseCandidate.isUnion ||
+        domains.size > 1 ||
+        hasNonNumericMembers;
+    if (!isUnion) {
+        return undefined;
+    }
+    return {
+        domains: sortNumericDomains(domains),
+        hasNonNumericMembers,
+        isUnion: true
+    };
+}
+function getExpressionNumericUnionCandidate(result) {
+    if (isNumericTypeDomain(result.domain)) {
+        return {
+            domains: [result.domain],
+            hasNonNumericMembers: false,
+            isUnion: false
+        };
+    }
+    if (result.unionDomains !== undefined && result.unionDomains.length > 0) {
+        return {
+            domains: result.unionDomains,
+            hasNonNumericMembers: result.hasNonNumericUnionMembers === true,
+            isUnion: true
+        };
+    }
+    return undefined;
+}
+function analyzeBinaryOperation(input, expression, operation) {
+    const leftWithoutContext = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.left,
+        symbols: input.symbols
+    });
+    const rightWithoutContext = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        expression: expression.right,
+        symbols: input.symbols
+    });
+    const contextualDomain = getBinaryContextualDomain(leftWithoutContext.domain, rightWithoutContext.domain);
+    const left = analyzeBinaryOperand(input, expression.left, contextualDomain);
+    const right = analyzeBinaryOperand(input, expression.right, contextualDomain);
+    const diagnostics = [
+        ...left.diagnostics,
+        ...right.diagnostics
+    ];
+    const unionDomains = getMergedAnalyzedOperandDomains([left, right]);
+    const hasNonNumericUnionMembers = [left, right].some((operand) => operand.hasNonNumericUnionMembers === true);
+    const resultDomain = getBinaryResultDomain(left.domain, right.domain);
+    const domainError = getDomainErrorDiagnostic(expression, operation.operator, left, right);
+    if (domainError !== undefined) {
+        diagnostics.push(domainError);
+        return createExpressionResult({
+            diagnostics,
+            domain: "unknown",
+            hasNonNumericUnionMembers,
+            reason: "unknown",
+            requiresClosure: false,
+            unionDomains
+        });
+    }
+    if (resultDomain === "plain-number" || resultDomain === "unknown") {
+        return createExpressionResult({
+            diagnostics,
+            domain: resultDomain,
+            hasNonNumericUnionMembers,
+            reason: resultDomain === "plain-number" ? "type" : "unknown",
+            requiresClosure: false,
+            unionDomains
+        });
+    }
+    if (operation.kind === "bitwise" &&
+        !supportsBitwiseOperator(resultDomain, operation.operator)) {
+        diagnostics.push(createDiagnostic("NUMTYPES_BITWISE_FLOAT", `cannot apply bitwise operator '${operation.operator}' to ${resultDomain}`, getDiagnosticLocation(expression)));
+        return createExpressionResult({
+            diagnostics,
+            domain: "unknown",
+            hasNonNumericUnionMembers,
+            reason: "unknown",
+            requiresClosure: false,
+            unionDomains
+        });
+    }
+    return createExpressionResult({
+        diagnostics,
+        domain: resultDomain,
+        reason: "operator",
+        requiresClosure: true
+    });
+}
+function analyzeBinaryOperand(input, expression, contextualDomain) {
+    const result = analyzeExpression({
+        cache: input.cache,
+        checker: input.checker,
+        contextualDomain,
+        expression,
+        symbols: input.symbols
+    });
+    return {
+        diagnostics: result.diagnostics,
+        domain: result.domain,
+        expression,
+        hasNonNumericUnionMembers: result.hasNonNumericUnionMembers,
+        isContextualLiteral: result.reason === "contextual-literal",
+        unionDomains: result.unionDomains
+    };
+}
+function analyzeExpressionType(input, expression) {
+    const typeResult = getTypeDomain({
+        checker: input.checker,
+        node: expression,
+        symbols: input.symbols,
+        type: input.checker.getTypeAtLocation(expression)
+    });
+    return createExpressionResult({
+        diagnostics: typeResult.diagnostics,
+        domain: typeResult.domain,
+        hasNonNumericUnionMembers: typeResult.hasNonNumericUnionMembers,
+        reason: typeResult.domain === "unknown" ? "unknown" : "type",
+        requiresClosure: isNumericTypeDomain(typeResult.domain),
+        unionDomains: typeResult.unionDomains
+    });
+}
+function createExpressionResult(input) {
+    const result = {
+        diagnostics: input.diagnostics,
+        domain: input.domain,
+        isDomainBound: isNumericTypeDomain(input.domain) ||
+            (input.unionDomains !== undefined && input.unionDomains.length > 0),
+        reason: input.reason,
+        requiresClosure: input.requiresClosure
+    };
+    if (input.unionDomains !== undefined && input.unionDomains.length > 0) {
+        return {
+            ...result,
+            hasNonNumericUnionMembers: input.hasNonNumericUnionMembers === true,
+            unionDomains: input.unionDomains
+        };
+    }
+    return result;
+}
+function getMergedAnalyzedOperandDomains(operands) {
+    const domains = new Set();
+    for (const operand of operands) {
+        for (const domain of operand.unionDomains ?? []) {
+            domains.add(domain);
+        }
+    }
+    return domains.size === 0 ? undefined : sortNumericDomains(domains);
+}
+function getMergedExpressionResultDomains(results) {
+    const domains = new Set();
+    for (const result of results) {
+        if (isNumericTypeDomain(result.domain)) {
+            domains.add(result.domain);
+        }
+        for (const domain of result.unionDomains ?? []) {
+            domains.add(domain);
+        }
+    }
+    return domains.size === 0 ? undefined : sortNumericDomains(domains);
+}
+function getBinaryContextualDomain(leftDomain, rightDomain) {
+    if (isNumericTypeDomain(leftDomain) && rightDomain === "plain-number") {
+        return leftDomain;
+    }
+    if (isNumericTypeDomain(rightDomain) && leftDomain === "plain-number") {
+        return rightDomain;
+    }
+    return undefined;
+}
+function getConditionalBranchContextualDomain(trueDomain, falseDomain) {
+    if (isNumericTypeDomain(trueDomain) && falseDomain === "plain-number") {
+        return trueDomain;
+    }
+    if (isNumericTypeDomain(falseDomain) && trueDomain === "plain-number") {
+        return falseDomain;
+    }
+    return undefined;
+}
+function getBinaryResultDomain(leftDomain, rightDomain) {
+    if (isNumericTypeDomain(leftDomain) && isNumericTypeDomain(rightDomain)) {
+        return leftDomain === rightDomain ? leftDomain : "unknown";
+    }
+    if (leftDomain === "plain-number" && rightDomain === "plain-number") {
+        return "plain-number";
+    }
+    if (isNumericTypeDomain(leftDomain) && rightDomain === "plain-number") {
+        return leftDomain;
+    }
+    if (leftDomain === "plain-number" && isNumericTypeDomain(rightDomain)) {
+        return rightDomain;
+    }
+    return "unknown";
+}
+function getConditionalResultDomain(trueDomain, falseDomain, contextualDomain) {
+    if (contextualDomain !== undefined &&
+        trueDomain === contextualDomain &&
+        falseDomain === contextualDomain) {
+        return contextualDomain;
+    }
+    if (isNumericTypeDomain(trueDomain) && isNumericTypeDomain(falseDomain)) {
+        return trueDomain === falseDomain ? trueDomain : "unknown";
+    }
+    if (trueDomain === "plain-number" && falseDomain === "plain-number") {
+        return "plain-number";
+    }
+    return "unknown";
+}
+function getCachedResult(cache, expression, contextualDomain) {
+    return cache.get(expression)?.get(getCacheKey(contextualDomain));
+}
+function setCachedResult(cache, expression, contextualDomain, result) {
+    const cacheKey = getCacheKey(contextualDomain);
+    const expressionCache = cache.get(expression) ?? new Map();
+    expressionCache.set(cacheKey, result);
+    cache.set(expression, expressionCache);
+}
+function getCacheKey(contextualDomain) {
+    return contextualDomain ?? "";
+}
+function getDomainErrorDiagnostic(expression, operator, left, right) {
+    const unionDomains = getMergedAnalyzedOperandDomains([left, right]);
+    if (unionDomains !== undefined) {
+        return createDiagnostic("NUMTYPES_UNSUPPORTED_UNION", `cannot ${getOperatorVerb(operator)} union containing ${unionDomains.join(" | ")}; narrow or explicitly cast before the operation`, getDiagnosticLocation(expression));
+    }
+    const leftDomain = left.domain;
+    const rightDomain = right.domain;
+    if (isNumericTypeDomain(leftDomain) && isNumericTypeDomain(rightDomain)) {
+        if (leftDomain !== rightDomain) {
+            return createDiagnostic("NUMTYPES_MIXED_DOMAIN", `cannot ${getOperatorVerb(operator)} ${leftDomain} and ${rightDomain} without explicit cast`, getDiagnosticLocation(expression));
+        }
+        return undefined;
+    }
+    if (isNumericTypeDomain(leftDomain) &&
+        rightDomain === "plain-number" &&
+        !right.isContextualLiteral) {
+        return createDiagnostic("NUMTYPES_IMPLICIT_NUMBER", `cannot ${getOperatorVerb(operator)} ${leftDomain} and number without explicit cast`, getDiagnosticLocation(expression));
+    }
+    if (leftDomain === "plain-number" &&
+        isNumericTypeDomain(rightDomain) &&
+        !left.isContextualLiteral) {
+        return createDiagnostic("NUMTYPES_IMPLICIT_NUMBER", `cannot ${getOperatorVerb(operator)} number and ${rightDomain} without explicit cast`, getDiagnosticLocation(expression));
+    }
+    return undefined;
+}
+function isContextualNumericLiteral(expression, contextualDomain) {
+    if (contextualDomain === undefined || !isNumericLiteralLike(expression)) {
+        return false;
+    }
+    const numericValue = getNumericLiteralValue(expression);
+    if (contextualDomain === "f32" || contextualDomain === "f64") {
+        return true;
+    }
+    if (!Number.isInteger(numericValue)) {
+        return false;
+    }
+    if (contextualDomain === "u32" && numericValue < 0) {
+        return false;
+    }
+    return true;
+}
+function isNumericLiteralLike(expression) {
+    if (ts.isNumericLiteral(expression)) {
+        return true;
+    }
+    return (ts.isPrefixUnaryExpression(expression) &&
+        (expression.operator === ts.SyntaxKind.MinusToken ||
+            expression.operator === ts.SyntaxKind.PlusToken) &&
+        ts.isNumericLiteral(expression.operand));
+}
+function getNumericLiteralValue(expression) {
+    if (ts.isNumericLiteral(expression)) {
+        return Number(expression.text);
+    }
+    if (ts.isPrefixUnaryExpression(expression) &&
+        ts.isNumericLiteral(expression.operand)) {
+        const value = Number(expression.operand.text);
+        return expression.operator === ts.SyntaxKind.MinusToken ? -value : value;
+    }
+    return Number.NaN;
+}
+function getUnaryArithmeticOperator(operator) {
+    return unaryArithmeticOperatorBySyntaxKind.get(operator);
+}
+function getBinaryArithmeticOperator(operator) {
+    return binaryArithmeticOperatorBySyntaxKind.get(operator);
+}
+function getIntegerBitwiseOperator(operator) {
+    return integerBitwiseOperatorBySyntaxKind.get(operator);
+}
+function getCompoundArithmeticOperator(operator) {
+    return compoundArithmeticOperatorBySyntaxKind.get(operator);
+}
+function getCompoundBitwiseOperator(operator) {
+    return compoundBitwiseOperatorBySyntaxKind.get(operator);
+}
+function getCompoundAssignmentText(operator) {
+    return ts.tokenToString(operator) ?? "<unknown>";
+}
+function getOperatorVerb(operator) {
+    switch (operator) {
+        case "+":
+            return "add";
+        case "-":
+            return "subtract";
+        case "*":
+            return "multiply";
+        case "/":
+            return "divide";
+        case "%":
+            return "remainder";
+        case "**":
+            return "exponentiate";
+        case "&":
+        case "|":
+        case "^":
+        case "<<":
+        case ">>":
+        case ">>>":
+            return `apply operator '${operator}' to`;
+    }
+}
+function getUnaryOperatorVerb(operator) {
+    switch (operator) {
+        case "+":
+            return "apply unary '+' to";
+        case "-":
+            return "negate";
+    }
+}
+function getUpdateOperatorVerb(operator) {
+    switch (operator) {
+        case ts.SyntaxKind.PlusPlusToken:
+            return "increment";
+        case ts.SyntaxKind.MinusMinusToken:
+            return "decrement";
+    }
+}
+function isUpdateOperator(operator) {
+    return (operator === ts.SyntaxKind.PlusPlusToken ||
+        operator === ts.SyntaxKind.MinusMinusToken);
+}
+function getUnsupportedUnionOperationDiagnostic(expression, operationVerb, operand) {
+    if (operand.unionDomains !== undefined && operand.unionDomains.length > 0) {
+        return createDiagnostic("NUMTYPES_UNSUPPORTED_UNION", `cannot ${operationVerb} union containing ${operand.unionDomains.join(" | ")}; narrow or explicitly cast before the operation`, getDiagnosticLocation(expression));
+    }
+    return undefined;
+}
+function skipParentheses(expression) {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+function getDiagnosticLocation(node) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const sourceFile = node.getSourceFile();
+    return {
+        fileName: sourceFile.fileName,
+        length: node.getWidth(sourceFile),
+        start: node.getStart(sourceFile)
+    };
+}
+//# sourceMappingURL=get-expression-domain.js.map