@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

package/dist/analyzer/operations.js

@@ -157,89 +157,7 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
         // 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 /* OperatorType.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 /* OperatorType.Add */ ||
-                            operator === 33 /* OperatorType.Subtract */ ||
-                            operator === 26 /* OperatorType.Multiply */ ||
-                            operator === 13 /* OperatorType.FloorDivide */ ||
-                            operator === 24 /* OperatorType.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 /* OperatorType.Add */) {
-                                            newValue = leftLiteralValue + rightLiteralValue;
-                                        }
-                                        else if (operator === 33 /* OperatorType.Subtract */) {
-                                            newValue = leftLiteralValue - rightLiteralValue;
-                                        }
-                                        else if (operator === 26 /* OperatorType.Multiply */) {
-                                            newValue = leftLiteralValue * rightLiteralValue;
-                                        }
-                                        else if (operator === 13 /* OperatorType.FloorDivide */) {
-                                            if (rightLiteralValue !== BigInt(0)) {
-                                                newValue = leftLiteralValue / rightLiteralValue;
-                                            }
-                                        }
-                                        else if (operator === 24 /* OperatorType.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;
-                            }
-                        }
-                    }
-                }
-            }
+            type = calcLiteralForBinaryOp(operator, leftType, rightType);
         }
         if (!type) {
             type = evaluator.mapSubtypesExpandTypeVars(leftType, 
@@ -254,10 +172,10 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
                         operator === 0 /* OperatorType.Add */ &&
                         (0, types_1.isClassInstance)(leftSubtypeExpanded) &&
                         (0, typeUtils_1.isTupleClass)(leftSubtypeExpanded) &&
-                        leftSubtypeExpanded.tupleTypeArguments &&
+                        leftSubtypeExpanded.priv.tupleTypeArguments &&
                         (0, types_1.isClassInstance)(rightSubtypeExpanded) &&
                         (0, typeUtils_1.isTupleClass)(rightSubtypeExpanded) &&
-                        rightSubtypeExpanded.tupleTypeArguments &&
+                        rightSubtypeExpanded.priv.tupleTypeArguments &&
                         tupleClassType &&
                         (0, types_1.isInstantiableClass)(tupleClassType)) {
                         // If at least one of the tuples is of fixed size, we can
@@ -268,8 +186,8 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
                         if (!(0, typeUtils_1.isUnboundedTupleClass)(leftSubtypeExpanded) ||
                             !(0, typeUtils_1.isUnboundedTupleClass)(rightSubtypeExpanded)) {
                             return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [
-                                ...leftSubtypeExpanded.tupleTypeArguments,
-                                ...rightSubtypeExpanded.tupleTypeArguments,
+                                ...leftSubtypeExpanded.priv.tupleTypeArguments,
+                                ...rightSubtypeExpanded.priv.tupleTypeArguments,
                             ]));
                         }
                     }
@@ -327,47 +245,47 @@ function validateBinaryOperation(evaluator, operator, leftTypeResult, rightTypeR
 }
 exports.validateBinaryOperation = validateBinaryOperation;
 function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
-    const leftExpression = node.leftExpression;
-    let rightExpression = node.rightExpression;
+    const leftExpression = node.d.leftExpr;
+    let rightExpression = node.d.rightExpr;
     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 ((0, parseTreeUtils_1.operatorSupportsChaining)(node.d.operator)) {
         if (rightExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
-            !rightExpression.parenthesized &&
-            (0, parseTreeUtils_1.operatorSupportsChaining)(rightExpression.operator)) {
+            !rightExpression.d.hasParens &&
+            (0, parseTreeUtils_1.operatorSupportsChaining)(rightExpression.d.operator)) {
             // Evaluate the right expression so it is type checked.
             getTypeOfBinaryOperation(evaluator, rightExpression, flags, inferenceContext);
             // Use the left side of the right expression for comparison purposes.
-            rightExpression = rightExpression.leftExpression;
+            rightExpression = rightExpression.d.leftExpr;
         }
     }
     // 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 /* OperatorType.Or */ || node.operator === 36 /* OperatorType.And */
+    let expectedOperandType = node.d.operator === 37 /* OperatorType.Or */ || node.d.operator === 36 /* OperatorType.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 /* OperatorType.Multiply */ &&
+    if (node.d.operator === 26 /* OperatorType.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 === 34 /* ParseNodeType.List */) {
+        inferenceContext.expectedType.priv.typeArguments &&
+        inferenceContext.expectedType.priv.typeArguments.length >= 1 &&
+        node.d.leftExpr.nodeType === 34 /* ParseNodeType.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 /* OperatorType.Or */ || node.operator === 36 /* OperatorType.And */) {
+        if (node.d.operator === 37 /* OperatorType.Or */ || node.d.operator === 36 /* OperatorType.And */) {
             // For "or" and "and", use the type of the left operand under certain
             // circumstances. This allows us to infer a better type for expressions
             // like `x or []`. Do this only if it's a generic class (like list or dict)
@@ -376,17 +294,17 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
                 if (!(0, types_1.isClassInstance)(subtype)) {
                     return false;
                 }
-                return types_1.ClassType.isTypedDictClass(subtype) || subtype.details.typeParameters.length > 0;
+                return types_1.ClassType.isTypedDictClass(subtype) || subtype.shared.typeParameters.length > 0;
             })) {
                 expectedOperandType = leftType;
             }
         }
-        else if (node.operator === 0 /* OperatorType.Add */ && node.rightExpression.nodeType === 34 /* ParseNodeType.List */) {
+        else if (node.d.operator === 0 /* OperatorType.Add */ && node.d.rightExpr.nodeType === 34 /* ParseNodeType.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 /* OperatorType.BitwiseOr */) {
+        else if (node.d.operator === 6 /* OperatorType.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)) {
@@ -401,7 +319,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
     }
     // Is this a "|" operator used in a context where it is supposed to be
     // interpreted as a union operator?
-    if (node.operator === 6 /* OperatorType.BitwiseOr */ &&
+    if (node.d.operator === 6 /* OperatorType.BitwiseOr */ &&
         !customMetaclassSupportsMethod(leftType, '__or__') &&
         !customMetaclassSupportsMethod(rightType, '__ror__')) {
         let adjustedRightType = rightType;
@@ -425,7 +343,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
                 // 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.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionSyntaxIllegal(), node, node.operatorToken);
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionSyntaxIllegal(), node, node.d.operatorToken);
                 }
             }
             const isLeftTypeArgValid = evaluator.validateTypeArg({ ...leftTypeResult, node: leftExpression });
@@ -433,9 +351,9 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
             if (!isLeftTypeArgValid || !isRightTypeArgValid) {
                 return { type: types_1.UnknownType.create() };
             }
-            adjustedLeftType = evaluator.reportMissingTypeArguments(node.leftExpression, adjustedLeftType, flags | 128 /* EvalFlags.InstantiableType */);
-            adjustedRightType = evaluator.reportMissingTypeArguments(node.rightExpression, adjustedRightType, flags | 128 /* EvalFlags.InstantiableType */);
-            let newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType]);
+            adjustedLeftType = evaluator.reportMissingTypeArguments(node.d.leftExpr, adjustedLeftType, flags | 128 /* EvalFlags.InstantiableType */);
+            adjustedRightType = evaluator.reportMissingTypeArguments(node.d.rightExpr, adjustedRightType, flags | 128 /* EvalFlags.InstantiableType */);
+            let newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType], { skipElideRedundantLiterals: true });
             const unionClass = evaluator.getUnionClassType();
             if (unionClass && (0, types_1.isInstantiableClass)(unionClass)) {
                 newUnion = types_1.TypeBase.cloneAsSpecialForm(newUnion, types_1.ClassType.cloneAsInstance(unionClass));
@@ -460,7 +378,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
                 if (stringNode && otherNode && otherType) {
                     let isAllowed = true;
                     if ((0, types_1.isClass)(otherType)) {
-                        if (!otherType.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
+                        if (!otherType.priv.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
                             isAllowed = false;
                         }
                     }
@@ -474,23 +392,23 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
     }
     if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
         // Exempt "|" because it might be a union operation involving unknowns.
-        if (node.operator !== 6 /* OperatorType.BitwiseOr */) {
+        if (node.d.operator !== 6 /* OperatorType.BitwiseOr */) {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.binaryOperationNotAllowed(), node);
             return { type: types_1.UnknownType.create() };
         }
     }
     // Optional checks apply to all operations except for boolean operations.
     let isLeftOptionalType = false;
-    if (booleanOperatorMap[node.operator] === undefined) {
+    if (booleanOperatorMap[node.d.operator] === undefined) {
         // None is a valid operand for == and != even if the type stub says otherwise.
-        if (node.operator === 12 /* OperatorType.Equals */ || node.operator === 28 /* OperatorType.NotEquals */) {
+        if (node.d.operator === 12 /* OperatorType.Equals */ || node.d.operator === 28 /* OperatorType.NotEquals */) {
             leftType = (0, typeUtils_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 /* OperatorType.Equals */ || node.operator === 28 /* OperatorType.NotEquals */) {
+        if (node.d.operator === 12 /* OperatorType.Equals */ || node.d.operator === 28 /* OperatorType.NotEquals */) {
             rightType = (0, typeUtils_1.removeNoneFromUnion)(rightType);
         }
     }
@@ -504,7 +422,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
     // 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);
-    const type = validateBinaryOperation(evaluator, node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
+    const type = validateBinaryOperation(evaluator, node.d.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
     if (!diag.isEmpty()) {
         typeErrors = true;
         if (!isIncomplete) {
@@ -514,8 +432,8 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
                 // this as a reportOptionalOperand diagnostic rather than a
                 // reportGeneralTypeIssues diagnostic.
                 evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.LocMessage.noneOperator().format({
-                    operator: (0, parseTreeUtils_1.printOperator)(node.operator),
-                }), node.leftExpression);
+                    operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
+                }), node.d.leftExpr);
             }
             else {
                 // If neither the LHS or RHS are unions, don't include a diagnostic addendum
@@ -527,7 +445,7 @@ function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
                     diagString = diag.getString();
                 }
                 evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportBinaryOperator().format({
-                    operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                    operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
                     leftType: evaluator.printType(leftType),
                     rightType: evaluator.printType(rightType),
                 }) + diagString, node);
@@ -556,15 +474,15 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
     let type;
     let typeResult;
     const diag = new diagnostic_1.DiagnosticAddendum();
-    const leftTypeResult = evaluator.getTypeOfExpression(node.leftExpression);
+    const leftTypeResult = evaluator.getTypeOfExpression(node.d.leftExpr);
     const leftType = leftTypeResult.type;
     let expectedOperandType;
-    if (node.operator === 7 /* OperatorType.BitwiseOrEqual */) {
+    if (node.d.operator === 7 /* OperatorType.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, 
+    const rightTypeResult = evaluator.getTypeOfExpression(node.d.rightExpr, 
     /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
     const rightType = rightTypeResult.type;
     const isIncomplete = !!rightTypeResult.isIncomplete || !!leftTypeResult.isIncomplete;
@@ -578,7 +496,7 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
                 if ((0, types_1.isAnyOrUnknown)(leftSubtypeUnexpanded) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
                     return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
                 }
-                const magicMethodName = operatorMap[node.operator][0];
+                const magicMethodName = operatorMap[node.d.operator][0];
                 let returnType = evaluator.getTypeOfMagicMethodCall(leftSubtypeUnexpanded, magicMethodName, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], node, inferenceContext);
                 if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                     // Try with the expanded left type.
@@ -591,11 +509,11 @@ function getTypeOfAugmentedAssignment(evaluator, 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];
+                    const binaryOperator = operatorMap[node.d.operator][1];
                     // Don't use literal math if the operation is within a loop
                     // because the literal values may change each time.
                     const isLiteralMathAllowed = !(0, parseTreeUtils_1.isWithinLoop)(node) &&
-                        isExpressionLocalVariable(evaluator, node.leftExpression) &&
+                        isExpressionLocalVariable(evaluator, node.d.leftExpr) &&
                         (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
@@ -612,7 +530,7 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
         if (!diag.isEmpty() || !type || (0, types_1.isNever)(type)) {
             if (!isIncomplete) {
                 evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportBinaryOperator().format({
-                    operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                    operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
                     leftType: evaluator.printType(leftType),
                     rightType: evaluator.printType(rightType),
                 }) + diag.getString(), node);
@@ -620,7 +538,7 @@ function getTypeOfAugmentedAssignment(evaluator, node, inferenceContext) {
         }
         typeResult = { type, isIncomplete };
     }
-    evaluator.assignTypeToExpression(node.destExpression, typeResult, node.rightExpression);
+    evaluator.assignTypeToExpression(node.d.destExpr, typeResult, node.d.rightExpr);
     return typeResult;
 }
 exports.getTypeOfAugmentedAssignment = getTypeOfAugmentedAssignment;
@@ -629,7 +547,7 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
         evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unaryOperationNotAllowed(), node);
         return { type: types_1.UnknownType.create() };
     }
-    const exprTypeResult = evaluator.getTypeOfExpression(node.expression);
+    const exprTypeResult = evaluator.getTypeOfExpression(node.d.expr);
     let exprType = evaluator.makeTopLevelTypeVarsConcrete((0, typeUtils_1.transformPossibleRecursiveTypeAlias)(exprTypeResult.type));
     const isIncomplete = exprTypeResult.isIncomplete;
     if ((0, types_1.isNever)(exprType)) {
@@ -643,11 +561,11 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
         [5 /* OperatorType.BitwiseInvert */]: '__invert__',
     };
     let type;
-    if (node.operator !== 38 /* OperatorType.Not */) {
+    if (node.d.operator !== 38 /* OperatorType.Not */) {
         if ((0, typeUtils_1.isOptionalType)(exprType)) {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.LocMessage.noneOperator().format({
-                operator: (0, parseTreeUtils_1.printOperator)(node.operator),
-            }), node.expression);
+                operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
+            }), node.d.expr);
             exprType = (0, typeUtils_1.removeNoneFromUnion)(exprType);
         }
     }
@@ -656,30 +574,37 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
     // is incomplete because we may be evaluating an expression within
     // a loop, so the literal value may change each time.
     if (!exprTypeResult.isIncomplete) {
+        const operator = node.d.operator;
         const literalClassName = (0, typeUtils_1.getLiteralTypeClassName)(exprType);
         if (literalClassName === 'int') {
-            if (node.operator === 0 /* OperatorType.Add */) {
+            if (operator === 0 /* OperatorType.Add */) {
                 type = exprType;
             }
-            else if (node.operator === 33 /* OperatorType.Subtract */) {
+            else if (operator === 33 /* OperatorType.Subtract */) {
+                type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
+                    const classSubtype = subtype;
+                    return types_1.ClassType.cloneWithLiteral(classSubtype, -classSubtype.priv.literalValue);
+                });
+            }
+            else if (operator === 5 /* OperatorType.BitwiseInvert */) {
                 type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
                     const classSubtype = subtype;
-                    return types_1.ClassType.cloneWithLiteral(classSubtype, -classSubtype.literalValue);
+                    return types_1.ClassType.cloneWithLiteral(classSubtype, ~classSubtype.priv.literalValue);
                 });
             }
         }
         else if (literalClassName === 'bool') {
-            if (node.operator === 38 /* OperatorType.Not */) {
+            if (operator === 38 /* OperatorType.Not */) {
                 type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
                     const classSubtype = subtype;
-                    return types_1.ClassType.cloneWithLiteral(classSubtype, !classSubtype.literalValue);
+                    return types_1.ClassType.cloneWithLiteral(classSubtype, !classSubtype.priv.literalValue);
                 });
             }
         }
     }
     if (!type) {
         // __not__ always returns a boolean.
-        if (node.operator === 38 /* OperatorType.Not */) {
+        if (node.d.operator === 38 /* OperatorType.Not */) {
             type = evaluator.getBuiltInObject(node, 'bool');
             if (!type) {
                 type = types_1.UnknownType.create();
@@ -690,7 +615,7 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
                 type = exprType;
             }
             else {
-                const magicMethodName = unaryOperatorMap[node.operator];
+                const magicMethodName = unaryOperatorMap[node.d.operator];
                 let isResultValid = true;
                 type = evaluator.mapSubtypesExpandTypeVars(exprType, /* options */ undefined, (subtypeExpanded) => {
                     const result = evaluator.getTypeOfMagicMethodCall(subtypeExpanded, magicMethodName, [], node, inferenceContext);
@@ -707,14 +632,14 @@ function getTypeOfUnaryOperation(evaluator, node, flags, inferenceContext) {
                 if (!isIncomplete) {
                     if (inferenceContext) {
                         evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportUnaryOperatorBidirectional().format({
-                            operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                            operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
                             type: evaluator.printType(exprType),
                             expectedType: evaluator.printType(inferenceContext.expectedType),
                         }), node);
                     }
                     else {
                         evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportUnaryOperator().format({
-                            operator: (0, parseTreeUtils_1.printOperator)(node.operator),
+                            operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
                             type: evaluator.printType(exprType),
                         }), node);
                     }
@@ -732,13 +657,13 @@ function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
         evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ternaryNotAllowed(), node);
         return { type: types_1.UnknownType.create() };
     }
-    evaluator.getTypeOfExpression(node.testExpression);
+    evaluator.getTypeOfExpression(node.d.testExpr);
     const typesToCombine = [];
     let isIncomplete = false;
     let typeErrors = false;
-    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);
+    const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.d.testExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
+    if (constExprValue !== false && evaluator.isNodeReachable(node.d.ifExpr)) {
+        const ifType = evaluator.getTypeOfExpression(node.d.ifExpr, flags, inferenceContext);
         typesToCombine.push(ifType.type);
         if (ifType.isIncomplete) {
             isIncomplete = true;
@@ -747,8 +672,8 @@ function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
             typeErrors = true;
         }
     }
-    if (constExprValue !== true && evaluator.isNodeReachable(node.elseExpression)) {
-        const elseType = evaluator.getTypeOfExpression(node.elseExpression, flags, inferenceContext);
+    if (constExprValue !== true && evaluator.isNodeReachable(node.d.elseExpr)) {
+        const elseType = evaluator.getTypeOfExpression(node.d.elseExpr, flags, inferenceContext);
         typesToCombine.push(elseType.type);
         if (elseType.isIncomplete) {
             isIncomplete = true;
@@ -760,11 +685,135 @@ function getTypeOfTernaryOperation(evaluator, node, flags, inferenceContext) {
     return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
 }
 exports.getTypeOfTernaryOperation = getTypeOfTernaryOperation;
+// Attempts to apply "literal math" for two literal operands.
+function calcLiteralForBinaryOp(operator, leftType, rightType) {
+    const leftLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(leftType);
+    if (!leftLiteralClassName || (0, typeUtils_1.getTypeCondition)(leftType)) {
+        return undefined;
+    }
+    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) {
+        return undefined;
+    }
+    // Handle str and bytes literals.
+    if (leftLiteralClassName === 'str' || leftLiteralClassName === 'bytes') {
+        if (operator === 0 /* OperatorType.Add */) {
+            return (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.priv.literalValue + rightClassSubtype.priv.literalValue));
+                });
+            });
+        }
+    }
+    // Handle int literals.
+    if (leftLiteralClassName === 'int') {
+        const supportedOps = [
+            0 /* OperatorType.Add */,
+            33 /* OperatorType.Subtract */,
+            26 /* OperatorType.Multiply */,
+            13 /* OperatorType.FloorDivide */,
+            24 /* OperatorType.Mod */,
+            29 /* OperatorType.Power */,
+            17 /* OperatorType.LeftShift */,
+            31 /* OperatorType.RightShift */,
+            3 /* OperatorType.BitwiseAnd */,
+            6 /* OperatorType.BitwiseOr */,
+            8 /* OperatorType.BitwiseXor */,
+        ];
+        if (!supportedOps.includes(operator)) {
+            return undefined;
+        }
+        let isValidResult = true;
+        const 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.priv.literalValue);
+                    const rightLiteralValue = BigInt(rightClassSubtype.priv.literalValue);
+                    let newValue;
+                    if (operator === 0 /* OperatorType.Add */) {
+                        newValue = leftLiteralValue + rightLiteralValue;
+                    }
+                    else if (operator === 33 /* OperatorType.Subtract */) {
+                        newValue = leftLiteralValue - rightLiteralValue;
+                    }
+                    else if (operator === 26 /* OperatorType.Multiply */) {
+                        newValue = leftLiteralValue * rightLiteralValue;
+                    }
+                    else if (operator === 13 /* OperatorType.FloorDivide */) {
+                        if (rightLiteralValue !== BigInt(0)) {
+                            newValue = leftLiteralValue / rightLiteralValue;
+                        }
+                    }
+                    else if (operator === 24 /* OperatorType.Mod */) {
+                        if (rightLiteralValue !== BigInt(0)) {
+                            newValue = leftLiteralValue % rightLiteralValue;
+                        }
+                    }
+                    else if (operator === 29 /* OperatorType.Power */) {
+                        if (rightLiteralValue >= BigInt(0)) {
+                            try {
+                                newValue = leftLiteralValue ** rightLiteralValue;
+                            }
+                            catch {
+                                // Don't allow if we exceed max bigint integer value.
+                            }
+                        }
+                    }
+                    else if (operator === 17 /* OperatorType.LeftShift */) {
+                        newValue = leftLiteralValue << rightLiteralValue;
+                    }
+                    else if (operator === 31 /* OperatorType.RightShift */) {
+                        newValue = leftLiteralValue >> rightLiteralValue;
+                    }
+                    else if (operator === 3 /* OperatorType.BitwiseAnd */) {
+                        newValue = leftLiteralValue & rightLiteralValue;
+                    }
+                    else if (operator === 6 /* OperatorType.BitwiseOr */) {
+                        newValue = leftLiteralValue | rightLiteralValue;
+                    }
+                    else if (operator === 8 /* OperatorType.BitwiseXor */) {
+                        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) {
+            return type;
+        }
+    }
+    return undefined;
+}
 function customMetaclassSupportsMethod(type, methodName) {
     if (!(0, types_1.isInstantiableClass)(type)) {
         return false;
     }
-    const metaclass = type.details.effectiveMetaclass;
+    const metaclass = type.shared.effectiveMetaclass;
     if (!metaclass || !(0, types_1.isInstantiableClass)(metaclass)) {
         return false;
     }
@@ -801,7 +850,7 @@ function isExpressionLocalVariable(evaluator, node) {
     if (node.nodeType !== 38 /* ParseNodeType.Name */) {
         return false;
     }
-    const symbolWithScope = evaluator.lookUpSymbolRecursive(node, node.value, /* honorCodeFlow */ false);
+    const symbolWithScope = evaluator.lookUpSymbolRecursive(node, node.d.value, /* honorCodeFlow */ false);
     if (!symbolWithScope) {
         return false;
     }