@zzzen/pyright-internal 1.2.0-dev.20230430 → 1.2.0-dev.20230514

package/dist/analyzer/operations.js

@@ -0,0 +1,749 @@
+"use strict";
+/*
+ * operations.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides type evaluation logic for unary, binary, augmented assignment,
+ * and ternary operators.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOfTernaryOperation = exports.getTypeOfUnaryOperation = exports.getTypeOfAugmentedAssignment = exports.getTypeOfBinaryOperation = exports.validateBinaryOperation = void 0;
+const diagnostic_1 = require("../common/diagnostic");
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const pythonVersion_1 = require("../common/pythonVersion");
+const localize_1 = require("../localization/localize");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const parseTreeUtils_1 = require("./parseTreeUtils");
+const staticExpressions_1 = require("./staticExpressions");
+const typeUtils_1 = require("./typeUtils");
+const types_1 = require("./types");
+// Maps binary operators to the magic methods that implement them.
+const binaryOperatorMap = {
+    [0 /* Add */]: ['__add__', '__radd__'],
+    [33 /* Subtract */]: ['__sub__', '__rsub__'],
+    [26 /* Multiply */]: ['__mul__', '__rmul__'],
+    [13 /* FloorDivide */]: ['__floordiv__', '__rfloordiv__'],
+    [10 /* Divide */]: ['__truediv__', '__rtruediv__'],
+    [24 /* Mod */]: ['__mod__', '__rmod__'],
+    [29 /* Power */]: ['__pow__', '__rpow__'],
+    [22 /* MatrixMultiply */]: ['__matmul__', '__rmatmul__'],
+    [3 /* BitwiseAnd */]: ['__and__', '__rand__'],
+    [6 /* BitwiseOr */]: ['__or__', '__ror__'],
+    [8 /* BitwiseXor */]: ['__xor__', '__rxor__'],
+    [17 /* LeftShift */]: ['__lshift__', '__rlshift__'],
+    [31 /* RightShift */]: ['__rshift__', '__rrshift__'],
+    [12 /* Equals */]: ['__eq__', '__eq__'],
+    [28 /* NotEquals */]: ['__ne__', '__ne__'],
+    [20 /* LessThan */]: ['__lt__', '__gt__'],
+    [21 /* LessThanOrEqual */]: ['__le__', '__ge__'],
+    [15 /* GreaterThan */]: ['__gt__', '__lt__'],
+    [16 /* GreaterThanOrEqual */]: ['__ge__', '__le__'],
+};
+// Map of operators that always return a bool result.
+const booleanOperatorMap = {
+    [36 /* And */]: true,
+    [37 /* Or */]: true,
+    [39 /* Is */]: true,
+    [40 /* IsNot */]: true,
+    [41 /* In */]: true,
+    [42 /* NotIn */]: true,
+};
+// If the number of subtypes starts to explode when applying "literal math",
+// cut off the literal union and fall back to the non-literal supertype.
+const maxLiteralMathSubtypeCount = 64;
+function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeResult, errorNode, inferenceContext, diag, options) {
+    const leftType = leftTypeResult.type;
+    const rightType = rightTypeResult.type;
+    let type;
+    let concreteLeftType = evaluator.makeTopLevelTypeVarsConcrete(leftType);
+    if (booleanOperatorMap[operator] !== undefined) {
+        // If it's an AND or OR, we need to handle short-circuiting by
+        // eliminating any known-truthy or known-falsy types.
+        if (operator === 36 /* And */) {
+            // If the LHS evaluates to falsy, the And expression will
+            // always return the type of the left-hand side.
+            if (!evaluator.canBeTruthy(concreteLeftType)) {
+                return leftType;
+            }
+            // If the LHS evaluates to truthy, the And expression will
+            // always return the type of the right-hand side.
+            if (!evaluator.canBeFalsy(concreteLeftType)) {
+                return rightType;
+            }
+            concreteLeftType = evaluator.removeTruthinessFromType(concreteLeftType);
+            if ((0, types_1.isNever)(rightType)) {
+                return concreteLeftType;
+            }
+        }
+        else if (operator === 37 /* Or */) {
+            // If the LHS evaluates to truthy, the Or expression will
+            // always return the type of the left-hand side.
+            if (!evaluator.canBeFalsy(concreteLeftType)) {
+                return leftType;
+            }
+            // If the LHS evaluates to falsy, the Or expression will
+            // always return the type of the right-hand side.
+            if (!evaluator.canBeTruthy(concreteLeftType)) {
+                return rightType;
+            }
+            concreteLeftType = evaluator.removeFalsinessFromType(concreteLeftType);
+            if ((0, types_1.isNever)(rightType)) {
+                return concreteLeftType;
+            }
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+            return types_1.NeverType.createNever();
+        }
+        // The "in" and "not in" operators make use of the __contains__
+        // magic method.
+        if (operator === 41 /* In */ || operator === 42 /* NotIn */) {
+            type = evaluator.mapSubtypesExpandTypeVars(rightType, 
+            /* conditionFilter */ undefined, (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
+                return evaluator.mapSubtypesExpandTypeVars(concreteLeftType, (0, typeUtils_1.getTypeCondition)(rightSubtypeExpanded), (leftSubtype) => {
+                    var _a;
+                    if ((0, types_1.isAnyOrUnknown)(leftSubtype) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
+                        return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
+                    }
+                    let returnType = evaluator.getTypeOfMagicMethodReturn(rightSubtypeExpanded, [{ type: leftSubtype, isIncomplete: leftTypeResult.isIncomplete }], '__contains__', errorNode, 
+                    /* inferenceContext */ undefined);
+                    if (!returnType) {
+                        // If __contains__ was not supported, fall back
+                        // on an iterable.
+                        const iteratorType = (_a = evaluator.getTypeOfIterator({ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }, 
+                        /* isAsync */ false, 
+                        /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
+                        if (iteratorType && evaluator.assignType(iteratorType, leftSubtype)) {
+                            returnType = evaluator.getBuiltInObject(errorNode, 'bool');
+                        }
+                    }
+                    if (!returnType) {
+                        diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
+                            operator: (0, parseTreeUtils_1.printOperator)(operator),
+                            leftType: evaluator.printType(leftSubtype),
+                            rightType: evaluator.printType(rightSubtypeExpanded),
+                        }));
+                    }
+                    return returnType;
+                });
+            });
+            // Assume that a bool is returned even if the type is unknown
+            if (type && !(0, types_1.isNever)(type)) {
+                type = evaluator.getBuiltInObject(errorNode, 'bool');
+            }
+        }
+        else {
+            type = evaluator.mapSubtypesExpandTypeVars(concreteLeftType, 
+            /* conditionFilter */ undefined, (leftSubtypeExpanded, leftSubtypeUnexpanded) => {
+                return evaluator.mapSubtypesExpandTypeVars(rightType, (0, typeUtils_1.getTypeCondition)(leftSubtypeExpanded), (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
+                    // If the operator is an AND or OR, we need to combine the two types.
+                    if (operator === 36 /* And */ || operator === 37 /* Or */) {
+                        return (0, types_1.combineTypes)([leftSubtypeUnexpanded, rightSubtypeUnexpanded]);
+                    }
+                    // The other boolean operators always return a bool value.
+                    return evaluator.getBuiltInObject(errorNode, 'bool');
+                });
+            });
+        }
+    }
+    else if (binaryOperatorMap[operator]) {
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+            return types_1.NeverType.createNever();
+        }
+        // Handle certain operations on certain homogenous literal types
+        // using special-case math. For example, Literal[1, 2] + Literal[3, 4]
+        // should result in Literal[4, 5, 6].
+        if (options.isLiteralMathAllowed) {
+            const leftLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(leftType);
+            if (leftLiteralClassName && !(0, typeUtils_1.getTypeCondition)(leftType)) {
+                const rightLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(rightType);
+                if (leftLiteralClassName === rightLiteralClassName &&
+                    !(0, typeUtils_1.getTypeCondition)(rightType) &&
+                    (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) < maxLiteralMathSubtypeCount) {
+                    if (leftLiteralClassName === 'str' || leftLiteralClassName === 'bytes') {
+                        if (operator === 0 /* Add */) {
+                            type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
+                                return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
+                                    const leftClassSubtype = leftSubtype;
+                                    const rightClassSubtype = rightSubtype;
+                                    return types_1.ClassType.cloneWithLiteral(leftClassSubtype, (leftClassSubtype.literalValue +
+                                        rightClassSubtype.literalValue));
+                                });
+                            });
+                        }
+                    }
+                    else if (leftLiteralClassName === 'int') {
+                        if (operator === 0 /* Add */ ||
+                            operator === 33 /* Subtract */ ||
+                            operator === 26 /* Multiply */ ||
+                            operator === 13 /* FloorDivide */ ||
+                            operator === 24 /* Mod */) {
+                            let isValidResult = true;
+                            type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
+                                return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
+                                    try {
+                                        const leftClassSubtype = leftSubtype;
+                                        const rightClassSubtype = rightSubtype;
+                                        const leftLiteralValue = BigInt(leftClassSubtype.literalValue);
+                                        const rightLiteralValue = BigInt(rightClassSubtype.literalValue);
+                                        let newValue;
+                                        if (operator === 0 /* Add */) {
+                                            newValue = leftLiteralValue + rightLiteralValue;
+                                        }
+                                        else if (operator === 33 /* Subtract */) {
+                                            newValue = leftLiteralValue - rightLiteralValue;
+                                        }
+                                        else if (operator === 26 /* Multiply */) {
+                                            newValue = leftLiteralValue * rightLiteralValue;
+                                        }
+                                        else if (operator === 13 /* FloorDivide */) {
+                                            if (rightLiteralValue !== BigInt(0)) {
+                                                newValue = leftLiteralValue / rightLiteralValue;
+                                            }
+                                        }
+                                        else if (operator === 24 /* Mod */) {
+                                            if (rightLiteralValue !== BigInt(0)) {
+                                                newValue = leftLiteralValue % rightLiteralValue;
+                                            }
+                                        }
+                                        if (newValue === undefined) {
+                                            isValidResult = false;
+                                            return undefined;
+                                        }
+                                        else if (typeof newValue === 'number' && isNaN(newValue)) {
+                                            isValidResult = false;
+                                            return undefined;
+                                        }
+                                        else {
+                                            // Convert back to a simple number if it fits. Leave as a bigint
+                                            // if it doesn't.
+                                            if (newValue >= Number.MIN_SAFE_INTEGER &&
+                                                newValue <= Number.MAX_SAFE_INTEGER) {
+                                                newValue = Number(newValue);
+                                            }
+                                            return types_1.ClassType.cloneWithLiteral(leftClassSubtype, newValue);
+                                        }
+                                    }
+                                    catch {
+                                        isValidResult = false;
+                                        return undefined;
+                                    }
+                                });
+                            });
+                            if (!isValidResult) {
+                                type = undefined;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!type) {
+            type = evaluator.mapSubtypesExpandTypeVars(leftType, 
+            /* conditionFilter */ undefined, (leftSubtypeExpanded, leftSubtypeUnexpanded) => {
+                return evaluator.mapSubtypesExpandTypeVars(rightType, (0, typeUtils_1.getTypeCondition)(leftSubtypeExpanded), (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
+                    if ((0, types_1.isAnyOrUnknown)(leftSubtypeUnexpanded) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
+                        return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
+                    }
+                    const tupleClassType = evaluator.getTupleClassType();
+                    // Special-case __add__ for tuples when the types for both tuples are known.
+                    if (options.isTupleAddAllowed &&
+                        operator === 0 /* Add */ &&
+                        (0, types_1.isClassInstance)(leftSubtypeExpanded) &&
+                        (0, typeUtils_1.isTupleClass)(leftSubtypeExpanded) &&
+                        leftSubtypeExpanded.tupleTypeArguments &&
+                        !(0, typeUtils_1.isUnboundedTupleClass)(leftSubtypeExpanded) &&
+                        (0, types_1.isClassInstance)(rightSubtypeExpanded) &&
+                        (0, typeUtils_1.isTupleClass)(rightSubtypeExpanded) &&
+                        rightSubtypeExpanded.tupleTypeArguments &&
+                        !(0, typeUtils_1.isUnboundedTupleClass)(rightSubtypeExpanded) &&
+                        tupleClassType &&
+                        (0, types_1.isInstantiableClass)(tupleClassType)) {
+                        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [
+                            ...leftSubtypeExpanded.tupleTypeArguments,
+                            ...rightSubtypeExpanded.tupleTypeArguments,
+                        ]));
+                    }
+                    const magicMethodName = binaryOperatorMap[operator][0];
+                    let resultType = evaluator.getTypeOfMagicMethodReturn(convertFunctionToObject(evaluator, leftSubtypeUnexpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, inferenceContext);
+                    if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
+                        // Try the expanded left type.
+                        resultType = evaluator.getTypeOfMagicMethodReturn(convertFunctionToObject(evaluator, leftSubtypeExpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, inferenceContext);
+                    }
+                    if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
+                        // Try the expanded left and right type.
+                        resultType = evaluator.getTypeOfMagicMethodReturn(convertFunctionToObject(evaluator, leftSubtypeExpanded), [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, inferenceContext);
+                    }
+                    if (!resultType) {
+                        // Try the alternate form (swapping right and left).
+                        const altMagicMethodName = binaryOperatorMap[operator][1];
+                        resultType = evaluator.getTypeOfMagicMethodReturn(convertFunctionToObject(evaluator, rightSubtypeUnexpanded), [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, inferenceContext);
+                        if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
+                            // Try the expanded right type.
+                            resultType = evaluator.getTypeOfMagicMethodReturn(convertFunctionToObject(evaluator, rightSubtypeExpanded), [
+                                {
+                                    type: leftSubtypeUnexpanded,
+                                    isIncomplete: leftTypeResult.isIncomplete,
+                                },
+                            ], altMagicMethodName, errorNode, inferenceContext);
+                        }
+                        if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
+                            // Try the expanded right and left type.
+                            resultType = evaluator.getTypeOfMagicMethodReturn(convertFunctionToObject(evaluator, rightSubtypeExpanded), [{ type: leftSubtypeExpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, inferenceContext);
+                        }
+                    }
+                    if (!resultType) {
+                        if (inferenceContext) {
+                            diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperatorBidirectional().format({
+                                operator: (0, parseTreeUtils_1.printOperator)(operator),
+                                leftType: evaluator.printType(leftSubtypeExpanded),
+                                rightType: evaluator.printType(rightSubtypeExpanded),
+                                expectedType: evaluator.printType(inferenceContext.expectedType),
+                            }));
+                        }
+                        else {
+                            diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
+                                operator: (0, parseTreeUtils_1.printOperator)(operator),
+                                leftType: evaluator.printType(leftSubtypeExpanded),
+                                rightType: evaluator.printType(rightSubtypeExpanded),
+                            }));
+                        }
+                    }
+                    return resultType;
+                });
+            });
+        }
+    }
+    return type && (0, types_1.isNever)(type) ? undefined : type;
+}
+exports.validateBinaryOperation = validateBinaryOperation;
+function getTypeOfBinaryOperation(evaluator, node, inferenceContext, flags) {
+    const leftExpression = node.leftExpression;
+    let rightExpression = node.rightExpression;
+    let isIncomplete = false;
+    let typeErrors = false;
+    // If this is a comparison and the left expression is also a comparison,
+    // we need to change the behavior to accommodate python's "chained
+    // comparisons" feature.
+    if ((0, parseTreeUtils_1.operatorSupportsChaining)(node.operator)) {
+        if (rightExpression.nodeType === 7 /* BinaryOperation */ &&
+            !rightExpression.parenthesized &&
+            (0, parseTreeUtils_1.operatorSupportsChaining)(rightExpression.operator)) {
+            // Evaluate the right expression so it is type checked.
+            getTypeOfBinaryOperation(evaluator, rightExpression, inferenceContext, flags);
+            // Use the left side of the right expression for comparison purposes.
+            rightExpression = rightExpression.leftExpression;
+        }
+    }
+    // For most binary operations, the "expected type" is applied to the output
+    // of the magic method for that operation. However, the "or" and "and" operators
+    // have no magic method, so we apply the expected type directly to both operands.
+    let expectedOperandType = node.operator === 37 /* Or */ || node.operator === 36 /* And */
+        ? inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType
+        : undefined;
+    // Handle the very special case where the expected type is a list
+    // and the operator is a multiply. This comes up in the common case
+    // of "x: List[Optional[X]] = [None] * y" where y is an integer literal.
+    let expectedLeftOperandType;
+    if (node.operator === 26 /* Multiply */ &&
+        inferenceContext &&
+        (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+        types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'list') &&
+        inferenceContext.expectedType.typeArguments &&
+        inferenceContext.expectedType.typeArguments.length >= 1 &&
+        node.leftExpression.nodeType === 31 /* List */) {
+        expectedLeftOperandType = inferenceContext.expectedType;
+    }
+    const effectiveExpectedType = expectedOperandType !== null && expectedOperandType !== void 0 ? expectedOperandType : expectedLeftOperandType;
+    const leftTypeResult = evaluator.getTypeOfExpression(leftExpression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
+    let leftType = leftTypeResult.type;
+    if (!expectedOperandType) {
+        if (node.operator === 37 /* Or */ || node.operator === 36 /* And */) {
+            // For "or" and "and", use the type of the left operand. This allows us to
+            // infer a better type for expressions like `x or []`.
+            expectedOperandType = leftType;
+        }
+        else if (node.operator === 0 /* Add */ && node.rightExpression.nodeType === 31 /* List */) {
+            // For the "+" operator , use this technique only if the right operand is
+            // a list expression. This heuristic handles the common case of `my_list + [0]`.
+            expectedOperandType = leftType;
+        }
+        else if (node.operator === 6 /* BitwiseOr */) {
+            // If this is a bitwise or ("|"), use the type of the left operand. This allows
+            // us to support the case where a TypedDict is being updated with a dict expression.
+            if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isTypedDictClass(leftType)) {
+                expectedOperandType = leftType;
+            }
+        }
+    }
+    const rightTypeResult = evaluator.getTypeOfExpression(rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
+    let rightType = rightTypeResult.type;
+    if (leftTypeResult.isIncomplete || rightTypeResult.isIncomplete) {
+        isIncomplete = true;
+    }
+    // Is this a "|" operator used in a context where it is supposed to be
+    // interpreted as a union operator?
+    if (node.operator === 6 /* BitwiseOr */ &&
+        !customMetaclassSupportsMethod(leftType, '__or__') &&
+        !customMetaclassSupportsMethod(rightType, '__ror__')) {
+        let adjustedRightType = rightType;
+        let adjustedLeftType = leftType;
+        if (!(0, types_1.isNoneInstance)(leftType) && (0, types_1.isNoneInstance)(rightType)) {
+            // Handle the special case where "None" is being added to the union
+            // with something else. Even though "None" will normally be interpreted
+            // as the None singleton object in contexts where a type annotation isn't
+            // assumed, we'll allow it here.
+            adjustedRightType = types_1.NoneType.createType();
+        }
+        else if (!(0, types_1.isNoneInstance)(rightType) && (0, types_1.isNoneInstance)(leftType)) {
+            adjustedLeftType = types_1.NoneType.createType();
+        }
+        if ((0, typeUtils_1.isUnionableType)([adjustedLeftType, adjustedRightType])) {
+            const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(node);
+            const unionNotationSupported = fileInfo.isStubFile ||
+                (flags & 4 /* AllowForwardReferences */) !== 0 ||
+                fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_10;
+            if (!unionNotationSupported) {
+                // If the left type is Any, we can't say for sure whether this
+                // is an illegal syntax or a valid application of the "|" operator.
+                if (!(0, types_1.isAnyOrUnknown)(adjustedLeftType)) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.unionSyntaxIllegal(), node, node.operatorToken);
+                }
+            }
+            if (!evaluator.validateTypeArg({ ...leftTypeResult, node: leftExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true }) ||
+                !evaluator.validateTypeArg({ ...rightTypeResult, node: rightExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
+                return { type: types_1.UnknownType.create() };
+            }
+            const newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType]);
+            if ((0, types_1.isUnion)(newUnion)) {
+                types_1.TypeBase.setSpecialForm(newUnion);
+            }
+            // Check for "stringified" forward reference type expressions. The "|" operator
+            // doesn't support these except in certain circumstances. Notably, it can't be used
+            // with other strings or with types that are not specialized using an index form.
+            if (!fileInfo.isStubFile) {
+                let stringNode;
+                let otherNode;
+                let otherType;
+                if (leftExpression.nodeType === 48 /* StringList */) {
+                    stringNode = leftExpression;
+                    otherNode = rightExpression;
+                    otherType = rightType;
+                }
+                else if (rightExpression.nodeType === 48 /* StringList */) {
+                    stringNode = rightExpression;
+                    otherNode = leftExpression;
+                    otherType = leftType;
+                }
+                if (stringNode && otherNode && otherType) {
+                    let isAllowed = true;
+                    if ((0, types_1.isClass)(otherType)) {
+                        if (!otherType.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
+                            isAllowed = false;
+                        }
+                    }
+                    if (!isAllowed) {
+                        evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionForwardReferenceNotAllowed(), stringNode);
+                    }
+                }
+            }
+            return { type: newUnion };
+        }
+    }
+    // Optional checks apply to all operations except for boolean operations.
+    let isLeftOptionalType = false;
+    if (booleanOperatorMap[node.operator] === undefined) {
+        // None is a valid operand for == and != even if the type stub says otherwise.
+        if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
+            leftType = (0, types_1.removeNoneFromUnion)(leftType);
+        }
+        else {
+            isLeftOptionalType = (0, typeUtils_1.isOptionalType)(leftType);
+        }
+        // None is a valid operand for == and != even if the type stub says otherwise.
+        if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
+            rightType = (0, types_1.removeNoneFromUnion)(rightType);
+        }
+    }
+    const diag = new diagnostic_1.DiagnosticAddendum();
+    // Don't use literal math if either of the operation is within a loop
+    // because the literal values may change each time.
+    const isLiteralMathAllowed = !(0, parseTreeUtils_1.isWithinLoop)(node);
+    // Don't special-case tuple __add__ if the left type is a union. This
+    // can result in an infinite loop if we keep creating new tuple types
+    // within a loop construct using __add__.
+    const isTupleAddAllowed = !(0, types_1.isUnion)(leftType);
+    let type = validateBinaryOperation(evaluator, node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
+    if (!diag.isEmpty() || !type) {
+        typeErrors = true;
+        if (!isIncomplete) {
+            const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(node);
+            if (isLeftOptionalType && diag.getMessages().length === 1) {
+                // If the left was an optional type and there is just one diagnostic,
+                // assume that it was due to a "None" not being supported. Report
+                // this as a reportOptionalOperand diagnostic rather than a
+                // reportGeneralTypeIssues diagnostic.
+                evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
+                    operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                }), node.leftExpression);
+            }
+            else {
+                // If neither the LHS or RHS are unions, don't include a diagnostic addendum
+                // because it will be redundant with the main diagnostic message. The addenda
+                // are useful only if union expansion was used for one or both operands.
+                let diagString = '';
+                if ((0, types_1.isUnion)(evaluator.makeTopLevelTypeVarsConcrete(leftType)) ||
+                    (0, types_1.isUnion)(evaluator.makeTopLevelTypeVarsConcrete(rightType))) {
+                    diagString = diag.getString();
+                }
+                evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
+                    operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                    leftType: evaluator.printType(leftType),
+                    rightType: evaluator.printType(rightType),
+                }) + diagString, node);
+            }
+        }
+        type = types_1.UnknownType.create();
+    }
+    return { type, isIncomplete, typeErrors };
+}
+exports.getTypeOfBinaryOperation = getTypeOfBinaryOperation;
+function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
+    const operatorMap = {
+        [1 /* AddEqual */]: ['__iadd__', 0 /* Add */],
+        [34 /* SubtractEqual */]: ['__isub__', 33 /* Subtract */],
+        [27 /* MultiplyEqual */]: ['__imul__', 26 /* Multiply */],
+        [14 /* FloorDivideEqual */]: ['__ifloordiv__', 13 /* FloorDivide */],
+        [11 /* DivideEqual */]: ['__itruediv__', 10 /* Divide */],
+        [25 /* ModEqual */]: ['__imod__', 24 /* Mod */],
+        [30 /* PowerEqual */]: ['__ipow__', 29 /* Power */],
+        [23 /* MatrixMultiplyEqual */]: ['__imatmul__', 22 /* MatrixMultiply */],
+        [4 /* BitwiseAndEqual */]: ['__iand__', 3 /* BitwiseAnd */],
+        [7 /* BitwiseOrEqual */]: ['__ior__', 6 /* BitwiseOr */],
+        [9 /* BitwiseXorEqual */]: ['__ixor__', 8 /* BitwiseXor */],
+        [18 /* LeftShiftEqual */]: ['__ilshift__', 17 /* LeftShift */],
+        [32 /* RightShiftEqual */]: ['__irshift__', 31 /* RightShift */],
+    };
+    let type;
+    let typeResult;
+    const diag = new diagnostic_1.DiagnosticAddendum();
+    const leftTypeResult = evaluator.getTypeOfExpression(node.leftExpression);
+    const leftType = leftTypeResult.type;
+    let expectedOperandType;
+    if (node.operator === 7 /* BitwiseOrEqual */) {
+        // If this is a bitwise or ("|="), use the type of the left operand. This allows
+        // us to support the case where a TypedDict is being updated with a dict expression.
+        expectedOperandType = leftType;
+    }
+    const rightTypeResult = evaluator.getTypeOfExpression(node.rightExpression, 
+    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
+    const rightType = rightTypeResult.type;
+    const isIncomplete = !!rightTypeResult.isIncomplete || !!leftTypeResult.isIncomplete;
+    if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+        typeResult = { type: types_1.NeverType.createNever(), isIncomplete };
+    }
+    else {
+        type = evaluator.mapSubtypesExpandTypeVars(leftType, 
+        /* conditionFilter */ undefined, (leftSubtypeExpanded, leftSubtypeUnexpanded) => {
+            return evaluator.mapSubtypesExpandTypeVars(rightType, (0, typeUtils_1.getTypeCondition)(leftSubtypeExpanded), (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
+                if ((0, types_1.isAnyOrUnknown)(leftSubtypeUnexpanded) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
+                    return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
+                }
+                const magicMethodName = operatorMap[node.operator][0];
+                let returnType = evaluator.getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, inferenceContext);
+                if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
+                    // Try with the expanded left type.
+                    returnType = evaluator.getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, inferenceContext);
+                }
+                if (!returnType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
+                    // Try with the expanded left and right type.
+                    returnType = evaluator.getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, inferenceContext);
+                }
+                if (!returnType) {
+                    // If the LHS class didn't support the magic method for augmented
+                    // assignment, fall back on the normal binary expression evaluator.
+                    const binaryOperator = operatorMap[node.operator][1];
+                    // Don't use literal math if either of the operation is within a loop
+                    // because the literal values may change each time.
+                    const isLiteralMathAllowed = !(0, parseTreeUtils_1.isWithinLoop)(node) &&
+                        (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
+                            maxLiteralMathSubtypeCount;
+                    // Don't special-case tuple __add__ if the left type is a union. This
+                    // can result in an infinite loop if we keep creating new tuple types
+                    // within a loop construct using __add__.
+                    const isTupleAddAllowed = !(0, types_1.isUnion)(leftType);
+                    returnType = validateBinaryOperation(evaluator, binaryOperator, { type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }, { type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
+                }
+                return returnType;
+            });
+        });
+        // If the LHS class didn't support the magic method for augmented
+        // assignment, fall back on the normal binary expression evaluator.
+        if (!diag.isEmpty() || !type || (0, types_1.isNever)(type)) {
+            if (!isIncomplete) {
+                const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(node);
+                evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
+                    operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                    leftType: evaluator.printType(leftType),
+                    rightType: evaluator.printType(rightType),
+                }) + diag.getString(), node);
+            }
+            type = types_1.UnknownType.create();
+        }
+        typeResult = { type, isIncomplete };
+    }
+    evaluator.assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
+    return typeResult;
+}
+exports.getTypeOfAugmentedAssignment = getTypeOfAugmentedAssignment;
+function getTypeOfUnaryOperation(evaluator, node, inferenceContext) {
+    const exprTypeResult = evaluator.getTypeOfExpression(node.expression);
+    let exprType = evaluator.makeTopLevelTypeVarsConcrete(exprTypeResult.type);
+    const isIncomplete = exprTypeResult.isIncomplete;
+    if ((0, types_1.isNever)(exprType)) {
+        return { type: types_1.NeverType.createNever(), isIncomplete };
+    }
+    // Map unary operators to magic functions. Note that the bitwise
+    // invert has two magic functions that are aliases of each other.
+    const unaryOperatorMap = {
+        [0 /* Add */]: '__pos__',
+        [33 /* Subtract */]: '__neg__',
+        [5 /* BitwiseInvert */]: '__invert__',
+    };
+    let type;
+    if (node.operator !== 38 /* Not */) {
+        if ((0, typeUtils_1.isOptionalType)(exprType)) {
+            evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(node).diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
+                operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+            }), node.expression);
+            exprType = (0, types_1.removeNoneFromUnion)(exprType);
+        }
+    }
+    // Handle certain operations on certain literal types
+    // using special-case math. Do not apply this if the input type
+    // is incomplete because we may be evaluating an expression within
+    // a loop, so the literal value may change each time.
+    if (!exprTypeResult.isIncomplete) {
+        const literalClassName = (0, typeUtils_1.getLiteralTypeClassName)(exprType);
+        if (literalClassName === 'int') {
+            if (node.operator === 0 /* Add */) {
+                type = exprType;
+            }
+            else if (node.operator === 33 /* Subtract */) {
+                type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
+                    const classSubtype = subtype;
+                    return types_1.ClassType.cloneWithLiteral(classSubtype, -classSubtype.literalValue);
+                });
+            }
+        }
+        else if (literalClassName === 'bool') {
+            if (node.operator === 38 /* Not */) {
+                type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
+                    const classSubtype = subtype;
+                    return types_1.ClassType.cloneWithLiteral(classSubtype, !classSubtype.literalValue);
+                });
+            }
+        }
+    }
+    if (!type) {
+        // __not__ always returns a boolean.
+        if (node.operator === 38 /* Not */) {
+            type = evaluator.getBuiltInObject(node, 'bool');
+            if (!type) {
+                type = types_1.UnknownType.create();
+            }
+        }
+        else {
+            if ((0, types_1.isAnyOrUnknown)(exprType)) {
+                type = exprType;
+            }
+            else {
+                const magicMethodName = unaryOperatorMap[node.operator];
+                type = evaluator.getTypeOfMagicMethodReturn(exprType, [], magicMethodName, node, inferenceContext);
+            }
+            if (!type) {
+                const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(node);
+                if (inferenceContext) {
+                    evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportUnaryOperatorBidirectional().format({
+                        operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                        type: evaluator.printType(exprType),
+                        expectedType: evaluator.printType(inferenceContext.expectedType),
+                    }), node);
+                }
+                else {
+                    evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportUnaryOperator().format({
+                        operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                        type: evaluator.printType(exprType),
+                    }), node);
+                }
+                type = types_1.UnknownType.create();
+            }
+        }
+    }
+    return { type, isIncomplete };
+}
+exports.getTypeOfUnaryOperation = getTypeOfUnaryOperation;
+function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
+    evaluator.getTypeOfExpression(node.testExpression);
+    const typesToCombine = [];
+    let isIncomplete = false;
+    let typeErrors = false;
+    const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(node);
+    const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.testExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+    if (constExprValue !== false && evaluator.isNodeReachable(node.ifExpression)) {
+        const ifType = evaluator.getTypeOfExpression(node.ifExpression, flags, inferenceContext);
+        typesToCombine.push(ifType.type);
+        if (ifType.isIncomplete) {
+            isIncomplete = true;
+        }
+        if (ifType.typeErrors) {
+            typeErrors = true;
+        }
+    }
+    if (constExprValue !== true && evaluator.isNodeReachable(node.elseExpression)) {
+        const elseType = evaluator.getTypeOfExpression(node.elseExpression, flags, inferenceContext);
+        typesToCombine.push(elseType.type);
+        if (elseType.isIncomplete) {
+            isIncomplete = true;
+        }
+        if (elseType.typeErrors) {
+            typeErrors = true;
+        }
+    }
+    return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
+}
+exports.getTypeOfTernaryOperation = getTypeOfTernaryOperation;
+function customMetaclassSupportsMethod(type, methodName) {
+    if (!(0, types_1.isInstantiableClass)(type)) {
+        return false;
+    }
+    const metaclass = type.details.effectiveMetaclass;
+    if (!metaclass || !(0, types_1.isInstantiableClass)(metaclass)) {
+        return false;
+    }
+    if (types_1.ClassType.isBuiltIn(metaclass, 'type')) {
+        return false;
+    }
+    const memberInfo = (0, typeUtils_1.lookUpClassMember)(metaclass, methodName);
+    if (!memberInfo) {
+        return false;
+    }
+    if ((0, types_1.isInstantiableClass)(memberInfo.classType) && types_1.ClassType.isBuiltIn(memberInfo.classType, 'type')) {
+        return false;
+    }
+    return true;
+}
+// All functions in Python derive from object, so they inherit all
+// of the capabilities of an object. This function converts a function
+// to an object instance.
+function convertFunctionToObject(evaluator, type) {
+    if ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type)) {
+        const objectType = evaluator.getObjectType();
+        if (objectType) {
+            return objectType;
+        }
+    }
+    return type;
+}
+//# sourceMappingURL=operations.js.map