@zzzen/pyright-internal 1.2.0-dev.20220717 → 1.2.0-dev.20220724

package/dist/analyzer/typeEvaluator.js

@@ -106,33 +106,31 @@ var MemberAccessFlags;
     MemberAccessFlags[MemberAccessFlags["SkipTypeBaseClass"] = 256] = "SkipTypeBaseClass";
 })(MemberAccessFlags || (MemberAccessFlags = {}));
 // Maps binary operators to the magic methods that implement them.
-// The boolean indicates whether the operators "chain" together.
 const binaryOperatorMap = {
-    [0 /* Add */]: ['__add__', '__radd__', false],
-    [33 /* Subtract */]: ['__sub__', '__rsub__', false],
-    [26 /* Multiply */]: ['__mul__', '__rmul__', false],
-    [13 /* FloorDivide */]: ['__floordiv__', '__rfloordiv__', false],
-    [10 /* Divide */]: ['__truediv__', '__rtruediv__', false],
-    [24 /* Mod */]: ['__mod__', '__rmod__', false],
-    [29 /* Power */]: ['__pow__', '__rpow__', false],
-    [22 /* MatrixMultiply */]: ['__matmul__', '__rmatmul__', false],
-    [3 /* BitwiseAnd */]: ['__and__', '__rand__', false],
-    [6 /* BitwiseOr */]: ['__or__', '__ror__', false],
-    [8 /* BitwiseXor */]: ['__xor__', '__rxor__', false],
-    [17 /* LeftShift */]: ['__lshift__', '__rlshift__', false],
-    [31 /* RightShift */]: ['__rshift__', '__rrshift__', false],
-    [12 /* Equals */]: ['__eq__', '__ne__', true],
-    [28 /* NotEquals */]: ['__ne__', '__eq__', true],
-    [20 /* LessThan */]: ['__lt__', '__ge__', true],
-    [21 /* LessThanOrEqual */]: ['__le__', '__gt__', true],
-    [15 /* GreaterThan */]: ['__gt__', '__le__', true],
-    [16 /* GreaterThanOrEqual */]: ['__ge__', '__lt__', true],
+    [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__', '__ne__'],
+    [28 /* NotEquals */]: ['__ne__', '__eq__'],
+    [20 /* LessThan */]: ['__lt__', '__ge__'],
+    [21 /* LessThanOrEqual */]: ['__le__', '__gt__'],
+    [15 /* GreaterThan */]: ['__gt__', '__le__'],
+    [16 /* GreaterThanOrEqual */]: ['__ge__', '__lt__'],
 };
-// Maps boolean operators to a boolean value indicating whether
-// the operators "chain" together with other comparison operators.
+// Map of operators that always return a bool result.
 const booleanOperatorMap = {
-    [36 /* And */]: false,
-    [37 /* Or */]: false,
+    [36 /* And */]: true,
+    [37 /* Or */]: true,
     [39 /* Is */]: true,
     [40 /* IsNot */]: true,
     [41 /* In */]: true,
@@ -283,6 +281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return cachedType !== undefined;
     }
     function readTypeCache(node, flags) {
+        var _a, _b;
         let cachedType;
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
@@ -299,8 +298,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (flags !== undefined) {
                 const expectedFlags = typeCacheFlags.get(node.id);
                 if (expectedFlags !== undefined && flags !== expectedFlags) {
-                    (0, debug_1.fail)(`Type cache flag mismatch for node type ${node.nodeType}: ` +
-                        `cached flags = ${expectedFlags}, access flags = ${flags}`);
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    const position = (0, positionUtils_1.convertOffsetToPosition)(node.start, fileInfo.lines);
+                    const message = `Type cache flag mismatch for node type ${node.nodeType} ` +
+                        `(parent ${(_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== null && _b !== void 0 ? _b : 'none'}): ` +
+                        `cached flags = ${expectedFlags}, access flags = ${flags}, ` +
+                        `file = {${fileInfo.filePath} [${position.line + 1}:${position.character + 1}]}`;
+                    if (evaluatorOptions.verifyTypeCacheEvaluatorFlags) {
+                        (0, debug_1.fail)(message);
+                    }
+                    else {
+                        console.log(message);
+                    }
                 }
             }
         }
@@ -428,9 +437,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // context. For example, if it's a subexpression of an argument expression,
     // the associated parameter type might inform the expected type.
     function getExpectedType(node) {
-        evaluateTypesForExpressionInContext(node);
+        // Scan up the parse tree to find the top-most expression node
+        // so we can evaluate the entire expression.
+        let topExpression = node;
         let curNode = node;
-        while (curNode !== undefined) {
+        while (curNode) {
+            if ((0, parseNodes_1.isExpressionNode)(curNode)) {
+                topExpression = curNode;
+            }
+            curNode = curNode.parent;
+        }
+        // Evaluate the expression. This will have the side effect of
+        // storing an expected type in the expected type cache.
+        evaluateTypesForExpressionInContext(topExpression);
+        // Look for the resulting expected type by scanning up the parse tree.
+        curNode = node;
+        while (curNode) {
             const expectedType = expectedTypeCache.get(curNode.id);
             if (expectedType) {
                 return {
@@ -438,6 +460,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     node: curNode,
                 };
             }
+            if (curNode === topExpression) {
+                break;
+            }
             curNode = curNode.parent;
         }
         return undefined;
@@ -470,7 +495,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (printExpressionTypes) {
                 console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cachedType)}`);
             }
-            return { type: cachedType, node };
+            return { type: cachedType };
         }
         else {
             // Is it cached in the speculative type cache?
@@ -479,7 +504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (printExpressionTypes) {
                     console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(speculativeCachedType)}`);
                 }
-                return { type: speculativeCachedType, node };
+                return { type: speculativeCachedType };
             }
         }
         if (printExpressionTypes) {
@@ -631,7 +656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         getTypeOfExpression(node.child);
                     }
                 });
-                typeResult = { type: types_1.UnknownType.create(), node };
+                typeResult = { type: types_1.UnknownType.create() };
                 break;
             }
             default:
@@ -683,7 +708,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const exprTypeResult = getTypeOfExpression(node.expression, flags, effectiveExpectedType);
         const typeResult = {
             type: getTypeOfAwaitable(exprTypeResult.type, node.expression),
-            node,
         };
         if (exprTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
@@ -692,26 +716,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfEllipsis(flags, typeResult, node) {
         if ((flags & 1 /* ConvertEllipsisToAny */) !== 0) {
-            typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true), node };
+            typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
         else if ((flags & 256 /* ConvertEllipsisToUnknown */) !== 0) {
-            typeResult = { type: types_1.UnknownType.create(), node };
+            typeResult = { type: types_1.UnknownType.create() };
         }
         else {
             const ellipsisType = getBuiltInObject(node, 'ellipsis') || types_1.AnyType.create();
-            typeResult = { type: ellipsisType, node };
+            typeResult = { type: ellipsisType };
         }
         return typeResult;
     }
     function getTypeOfNumber(node, typeResult) {
         if (node.isImaginary) {
-            typeResult = { node, type: getBuiltInObject(node, 'complex') };
+            typeResult = { type: getBuiltInObject(node, 'complex') };
         }
         else if (node.isInteger) {
-            typeResult = { node, type: cloneBuiltinObjectWithLiteral(node, 'int', node.value) };
+            typeResult = { type: cloneBuiltinObjectWithLiteral(node, 'int', node.value) };
         }
         else {
-            typeResult = { node, type: getBuiltInObject(node, 'float') };
+            typeResult = { type: getBuiltInObject(node, 'float') };
         }
         return typeResult;
     }
@@ -730,17 +754,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 128 /* TypeVarTupleDisallowed */) === 0 &&
             (0, types_1.isVariadicTypeVar)(iterType) &&
             !iterType.isVariadicUnpacked) {
-            typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType), node };
+            typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
         else {
             if ((flags & 2097152 /* AllowUnpackedTupleOrTypeVarTuple */) !== 0 &&
                 (0, types_1.isInstantiableClass)(iterType) &&
                 types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
-                typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType), node };
+                typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
             }
             else {
                 const type = (_a = getTypeOfIterator(iterType, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(!!iterTypeResult.isIncomplete);
-                typeResult = { type, unpackedType: iterType, node, isIncomplete: iterTypeResult.isIncomplete };
+                typeResult = { type, unpackedType: iterType, isIncomplete: iterTypeResult.isIncomplete };
             }
         }
         return typeResult;
@@ -769,7 +793,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeResult) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.expectedTypeNotString(), node);
-                typeResult = { node, type: types_1.UnknownType.create() };
+                typeResult = { type: types_1.UnknownType.create() };
             }
         }
         else {
@@ -785,13 +809,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Don't create a literal type if it's an f-string.
             if (node.strings.some((str) => str.nodeType === 27 /* FormatString */)) {
                 typeResult = {
-                    node,
                     type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
                 };
             }
             else {
                 typeResult = {
-                    node,
                     type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.strings.map((s) => s.value).join('')),
                 };
             }
@@ -804,13 +826,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Don't create a literal type if it's an f-string.
         if (node.nodeType === 27 /* FormatString */) {
             typeResult = {
-                node,
                 type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
             };
         }
         else {
             typeResult = {
-                node,
                 type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.value),
             };
         }
@@ -1143,7 +1163,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* isAccessedThroughObject */ true, memberName, usage, diag, memberAccessFlags | 8 /* DisallowClassVarWrites */, bindToType);
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
@@ -1157,7 +1176,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let memberInfo;
         if (types_1.ClassType.isPartiallyEvaluated(classType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: classType.details.name }), errorNode);
-            return { node: errorNode, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         if ((memberAccessFlags & 32 /* ConsiderMetaclassOnly */) === 0) {
             memberInfo = getTypeOfClassMemberName(errorNode, classType, 
@@ -1189,7 +1208,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
@@ -1509,6 +1527,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         const nextMethodName = isAsync ? '__anext__' : '__next__';
         let isValidIterator = true;
+        type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
         type = makeTopLevelTypeVarsConcrete(type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
             if (errorNode) {
@@ -1904,9 +1923,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeIncomplete) {
             reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
         }
-        writeTypeCache(nameNode, destType, 0 /* None */, isTypeIncomplete, 
-        /* expectedType */ undefined, 
-        /* allowSpeculativeCaching */ false);
+        writeTypeCache(nameNode, destType, 0 /* None */, isTypeIncomplete);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
@@ -1950,12 +1967,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (setTypeResult.isAsymmetricDescriptor) {
             setAsymmetricDescriptorAssignment(target);
         }
-        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete, 
-        /* expectedType */ undefined, 
-        /* allowSpeculativeCaching */ false);
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete, 
-        /* expectedType */ undefined, 
-        /* allowSpeculativeCaching */ false);
+        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
         const memberName = node.memberName.value;
@@ -2164,7 +2177,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                     /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true, 
                     /* isUnpackedTuple */ true));
                 }
             }
@@ -2476,7 +2488,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 35 /* MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression);
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
                 const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
                 writeTypeCache(node.memberName, memberType.type, 0 /* None */, /* isIncomplete */ false);
                 writeTypeCache(node, memberType.type, 0 /* None */, /* isIncomplete */ false);
@@ -2574,7 +2586,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
             if (containingFunction && ParseTreeUtils.isUnannotatedFunction(containingFunction)) {
                 return {
-                    node,
                     type: types_1.AnyType.create(),
                     isIncomplete: false,
                 };
@@ -2718,7 +2729,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(type) && !type.details.isSynthesized) {
             type = validateTypeVarUsage(node, type, flags);
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (either a function or a lambda).
@@ -3016,7 +3027,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             return {
-                node,
                 type: types_1.UnknownType.create(/* isIncomplete */ true),
                 isIncomplete: true,
             };
@@ -3076,7 +3086,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the base type was incomplete and unbound, don't proceed
         // because false positive errors will be generated.
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseTypeResult.type)) {
-            return { type: types_1.UnknownType.create(/* isIncomplete */ true), node, isIncomplete: true };
+            return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         // Handle the special case where the expression is an actual
         // UnionType special form.
@@ -3112,22 +3122,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
                         if (!paramNode || paramNode.category !== 1 /* VarArgList */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecArgsUsage(), node);
-                            return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                            return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
-                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'args'), node, isIncomplete };
+                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'args'), isIncomplete };
                     }
                     if (memberName === 'kwargs') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
                         if (!paramNode || paramNode.category !== 2 /* VarArgDictionary */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecKwargsUsage(), node);
-                            return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                            return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
-                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'kwargs'), node, isIncomplete };
+                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'kwargs'), isIncomplete };
                     }
                     if (!isIncomplete) {
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecUnknownMember().format({ name: memberName }), node);
                     }
-                    return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                    return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
                 if (flags & 64 /* ExpectingType */) {
                     if (!isIncomplete) {
@@ -3136,14 +3146,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             name: memberName,
                         }), node.leftExpression);
                     }
-                    return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                    return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
                 if (baseType.details.recursiveTypeAliasName) {
-                    return { type: types_1.UnknownType.create(/* isIncomplete */ true), node, isIncomplete: true };
+                    return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
                 }
                 return getTypeOfMemberAccessWithBaseType(node, {
                     type: makeTopLevelTypeVarsConcrete(baseType),
-                    node,
                     bindToType: baseType,
                     isIncomplete,
                 }, usage, 0 /* None */);
@@ -3174,14 +3183,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 const strClass = getBuiltInType(node, 'str');
                                 if ((0, types_1.isInstantiableClass)(strClass)) {
                                     return {
-                                        node,
                                         type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(strClass, literalValue.itemName)),
                                         isIncomplete,
                                     };
                                 }
                             }
                             else if (memberName === 'value' || memberName === '_value_') {
-                                return { node, type: literalValue.itemType, isIncomplete };
+                                return { type: literalValue.itemType, isIncomplete };
                             }
                         }
                     }
@@ -3285,7 +3293,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const typeResult = getTypeOfMemberAccessWithBaseType(node, {
                             type: subtype,
-                            node,
                             isIncomplete: baseTypeResult.isIncomplete,
                         }, usage, 0 /* None */);
                         if (typeResult.isIncomplete) {
@@ -3317,7 +3324,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type = types_1.AnyType.create();
                     }
                     else {
-                        type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj, node }, usage, flags).type;
+                        type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj }, usage, flags).type;
                     }
                 }
                 break;
@@ -3387,7 +3394,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* ignoreEmptyContainers */ false);
             }
         }
-        return { type, node, isIncomplete, isAsymmetricDescriptor };
+        return { type, isIncomplete, isAsymmetricDescriptor };
     }
     function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
         var _a, _b;
@@ -4026,7 +4033,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         const tupleObject = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, variadicTypes, 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         typeArgs = [
                             ...typeArgs.slice(0, variadicIndex),
@@ -4041,7 +4047,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         node: errorNode,
                         type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true)),
                     });
                 }
@@ -4202,9 +4207,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
             const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
-            return { type, node };
+            return { type };
         }
-        let isIncomplete = false;
+        let isIncomplete = baseTypeResult.isIncomplete;
         const type = mapSubtypesExpandTypeVars(baseTypeResult.type, 
         /* conditionFilter */ undefined, (concreteSubtype, unexpandedSubtype) => {
             var _a;
@@ -4299,11 +4304,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isNever)(concreteSubtype)) {
                 return types_1.UnknownType.create();
             }
-            if ((0, types_1.isNoneInstance)(concreteSubtype)) {
+            if ((0, types_1.isNoneInstance)(concreteSubtype) && !isIncomplete) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalSubscript, diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.Localizer.Diagnostic.noneNotSubscriptable(), node.baseExpression);
                 return types_1.UnknownType.create();
             }
-            if (!(0, types_1.isUnbound)(concreteSubtype)) {
+            if (!(0, types_1.isUnbound)(concreteSubtype) && !isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
             }
@@ -4318,7 +4323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function makeTupleObject(entryTypes, isUnspecifiedLength = false) {
         if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4363,7 +4368,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 name: magicMethodName,
                 type: printType(baseType),
             }), node.baseExpression);
-            return { node, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         // Handle the special case where the object is a Tuple and
         // the index is a constant number (integer) or a slice with integer
@@ -4384,11 +4389,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
                 if (tupleType && tupleType.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
                     if (indexValue >= 0 && indexValue < tupleType.tupleTypeArguments.length) {
-                        return { node, type: tupleType.tupleTypeArguments[indexValue].type };
+                        return { type: tupleType.tupleTypeArguments[indexValue].type };
                     }
                     else if (indexValue < 0 && tupleType.tupleTypeArguments.length + indexValue >= 0) {
                         return {
-                            node,
                             type: tupleType.tupleTypeArguments[tupleType.tupleTypeArguments.length + indexValue].type,
                         };
                     }
@@ -4426,7 +4430,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             tupleClassType &&
                             (0, types_1.isInstantiableClass)(tupleClassType)) {
                             return {
-                                node,
                                 type: types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleType.tupleTypeArguments.slice(startValue, endValue))),
                             };
                         }
@@ -4541,7 +4544,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
-            node,
             type: (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
@@ -4569,10 +4571,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // treated as types. If it's an Annotated[a, b, c], only the first index
             // should be treated as a type. The others can be regular (non-type) objects.
             if (hasCustomClassGetItem || (isAnnotatedClass && argIndex > 0)) {
-                typeResult = getTypeOfExpression(expr, 32 /* ParamSpecDisallowed */ |
-                    128 /* TypeVarTupleDisallowed */ |
-                    2 /* DoNotSpecialize */ |
-                    131072 /* ClassVarDisallowed */);
+                typeResult = {
+                    ...getTypeOfExpression(expr, 32 /* ParamSpecDisallowed */ |
+                        128 /* TypeVarTupleDisallowed */ |
+                        2 /* DoNotSpecialize */ |
+                        131072 /* ClassVarDisallowed */),
+                    node: expr,
+                };
             }
             else {
                 typeResult = getTypeArg(expr, adjFlags);
@@ -4618,7 +4623,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let typeResult;
         let adjustedFlags = flags |
             64 /* ExpectingType */ |
-            1024 /* ExpectingTypeAnnotation */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4628,14 +4632,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.nodeType === 31 /* List */) {
             typeResult = {
                 type: types_1.UnknownType.create(),
-                typeList: node.entries.map((entry) => getTypeOfExpression(entry, adjustedFlags)),
+                typeList: node.entries.map((entry) => {
+                    return { ...getTypeOfExpression(entry, adjustedFlags), node: entry };
+                }),
                 node,
             };
             // Set the node's type so it isn't reevaluated later.
             setTypeForNode(node, types_1.UnknownType.create());
         }
         else {
-            typeResult = getTypeOfExpression(node, adjustedFlags);
+            typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
             // "Protocol" is not allowed as a type argument.
             if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'Protocol')) {
                 addError(localize_1.Localizer.Diagnostic.protocolNotAllowedInTypeArgument(), node);
@@ -4651,7 +4657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfTuple(node, expectedType, flags) {
         if ((flags & 64 /* ExpectingType */) !== 0 && node.expressions.length === 0 && !expectedType) {
-            return { type: makeTupleObject([]), node, isEmptyTupleShorthand: true };
+            return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
@@ -4728,20 +4734,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
         /* flags */ undefined, index < expectedTypes.length ? expectedTypes[index] : undefined));
-        const expectedTypesContainLiterals = expectedTypes.some((type) => (0, typeUtils_1.isLiteralTypeOrUnion)(type));
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
-        /* isTypeArgumentExplicit */ true, 
-        /* stripLiterals */ !expectedTypesContainLiterals));
-        return { type, node };
+        /* isTypeArgumentExplicit */ true));
+        return { type };
     }
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         if (!tupleClassType || !(0, types_1.isInstantiableClass)(tupleClassType)) {
-            return { type: types_1.UnknownType.create(), node };
+            return { type: types_1.UnknownType.create() };
         }
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function buildTupleTypesList(entryTypeResults) {
         const entryTypes = [];
@@ -4797,7 +4801,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             };
             return functionArg;
         });
-        let typeResult = { node, type: types_1.UnknownType.create() };
+        let typeResult = { type: types_1.UnknownType.create() };
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === 'super') {
                 // Handle the built-in "super" call specially.
@@ -4871,7 +4875,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationCall(), node);
-            typeResult = { node, type: types_1.UnknownType.create() };
+            typeResult = { type: types_1.UnknownType.create() };
         }
         return typeResult;
     }
@@ -4882,12 +4886,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.arguments[0].argumentCategory !== 0 /* Simple */ ||
             node.arguments[1].name !== undefined) {
             addError(localize_1.Localizer.Diagnostic.assertTypeArgs(), node);
-            return { node, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         const arg0TypeResult = getTypeOfExpression(node.arguments[0].valueExpression, 
         /* flags */ undefined, expectedType);
         if (arg0TypeResult.isIncomplete) {
-            return { node, type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
+            return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgumentExpectingType(node.arguments[1]).type);
         if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type)) {
@@ -4896,7 +4900,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 received: printType(arg0TypeResult.type),
             }), node.arguments[0].valueExpression);
         }
-        return { node, type: arg0TypeResult.type };
+        return { type: arg0TypeResult.type };
     }
     function getTypeOfRevealType(node, expectedType) {
         let arg0Value;
@@ -4933,7 +4937,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         if (!arg0Value) {
             addError(localize_1.Localizer.Diagnostic.revealTypeArgs(), node);
-            return { node, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, expectedType);
         const type = typeResult.type;
@@ -4957,11 +4961,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         addInformation(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({ name: exprString, type: typeString }), node.arguments[0]);
-        return {
-            node,
-            type,
-            isIncomplete: typeResult.isIncomplete,
-        };
+        return { type, isIncomplete: typeResult.isIncomplete };
     }
     function getTypeOfRevealLocals(node) {
         let curNode = node;
@@ -5110,7 +5110,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: resultIsInstance
                         ? types_1.ClassType.cloneAsInstance(lookupResults.classType)
                         : lookupResults.classType,
-                    node,
                     bindToType: resultIsInstance && bindToType && (0, types_1.isInstantiableClass)(bindToType)
                         ? types_1.ClassType.cloneAsInstance(bindToType)
                         : bindToType,
@@ -5123,10 +5122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If the class derives from one or more unknown classes,
             // return unknown here to prevent spurious errors.
             if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
-                return {
-                    type: types_1.UnknownType.create(),
-                    node,
-                };
+                return { type: types_1.UnknownType.create() };
             }
             const baseClasses = targetClassType.details.baseClasses;
             if (baseClasses.length > 0) {
@@ -5134,15 +5130,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isInstantiableClass)(baseClassType)) {
                     return {
                         type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
-                        node,
                     };
                 }
             }
         }
-        return {
-            type: types_1.UnknownType.create(),
-            node,
-        };
+        return { type: types_1.UnknownType.create() };
     }
     // Attempts to find an overloaded function for each set of argument
     // types in the expandedArgTypes list. If an argument type is undefined,
@@ -5152,6 +5144,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
     function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, expectedType) {
+        var _a;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
@@ -5173,11 +5166,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return argParamCopy;
                     });
                 }
-                // Clone the typeVarContext so we don't modify the original.
-                const effectiveTypeVarContext = typeVarContext
-                    ? typeVarContext.clone()
-                    : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+                // Clone the typeVarContext so we don't modify the original. If this is
+                // not the first time through the loop, clone the type var context
+                // from the previous successful match.
+                const typeVarContextToClone = matchedOverloads.length > 0
+                    ? matchedOverloads[matchedOverloads.length - 1].typeVarContext.clone()
+                    : typeVarContext;
+                const effectiveTypeVarContext = (_a = typeVarContextToClone === null || typeVarContextToClone === void 0 ? void 0 : typeVarContextToClone.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
                 effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(overload));
+                effectiveTypeVarContext.unlock();
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(errorNode, () => {
@@ -5202,24 +5199,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return { argumentErrors: true, isTypeIncomplete };
             }
         }
-        // We found a match for all of the expanded argument lists.
-        // Run through them again to populate the original typeVarContext.
+        // We found a match for all of the expanded argument lists. Copy the
+        // resulting type var context back into the caller's type var context.
+        // Use the type var context from the last matched overload because it
+        // includes the type var solutions for all earlier matched overloads.
         if (typeVarContext) {
-            for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
-                const overload = matchedOverloads[expandedTypesIndex].overload;
-                const matchResults = matchedOverloads[expandedTypesIndex].matchResults;
-                useSpeculativeMode(errorNode, () => {
-                    typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(overload));
-                    typeVarContext.unlock();
-                    return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, 
-                    /* skipUnknownArgCheck */ true, expectedType);
-                });
-            }
+            typeVarContext.copyFromClone(matchedOverloads[matchedOverloads.length - 1].typeVarContext);
         }
         // And run through the first expanded argument list one more time to
         // populate the type cache.
-        matchedOverloads[0].typeVarContext.unlock();
-        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, matchedOverloads[0].typeVarContext, skipUnknownArgCheck, expectedType);
+        const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
+        finalTypeVarContext.unlock();
+        finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
+        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, expectedType);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -6708,7 +6700,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                         const specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         const combinedArg = {
                             paramCategory: 1 /* VarArgList */,
@@ -7427,9 +7418,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
-                        const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
-                        /* allowFinal */ undefined, 
-                        /* allowRequired */ undefined).type;
+                        const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
                             addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), argList[i].valueExpression || errorNode);
                         }
@@ -7466,9 +7455,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
-                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
-                    /* allowFinal */ undefined, 
-                    /* allowRequired */ undefined).type;
+                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
                         addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), argList[i].valueExpression || errorNode);
                     }
@@ -7746,14 +7733,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!type) {
             return undefined;
         }
-        return { type, node };
+        return { type };
     }
     function getTypeOfUnaryOperation(node, expectedType) {
         const exprTypeResult = getTypeOfExpression(node.expression);
         let exprType = makeTopLevelTypeVarsConcrete(exprTypeResult.type);
         const isIncomplete = exprTypeResult.isIncomplete;
         if ((0, types_1.isNever)(exprType)) {
-            return { node, type: types_1.NeverType.createNever(), isIncomplete };
+            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.
@@ -7832,16 +7819,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        return { type, node, isIncomplete };
-    }
-    function operatorSupportsComparisonChaining(op) {
-        if (binaryOperatorMap[op] && binaryOperatorMap[op][2]) {
-            return true;
-        }
-        if (booleanOperatorMap[op]) {
-            return true;
-        }
-        return false;
+        return { type, isIncomplete };
     }
     function getTypeOfBinaryOperation(node, expectedType, flags) {
         const leftExpression = node.leftExpression;
@@ -7850,10 +7828,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // 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 (operatorSupportsComparisonChaining(node.operator)) {
+        if (ParseTreeUtils.operatorSupportsChaining(node.operator)) {
             if (rightExpression.nodeType === 7 /* BinaryOperation */ &&
                 !rightExpression.parenthesized &&
-                operatorSupportsComparisonChaining(rightExpression.operator)) {
+                ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
                 // Evaluate the right expression so it is type checked.
                 getTypeOfBinaryOperation(rightExpression, expectedType, flags);
                 // Use the left side of the right expression for comparison purposes.
@@ -7930,15 +7908,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.unionSyntaxIllegal(), node, node.operatorToken);
                     }
                 }
-                if (!validateTypeArg(leftTypeResult, { allowVariadicTypeVar: true, allowUnpackedTuples: true }) ||
-                    !validateTypeArg(rightTypeResult, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
-                    return { type: types_1.UnknownType.create(), node };
+                if (!validateTypeArg({ ...leftTypeResult, node: leftExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true }) ||
+                    !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);
                 }
-                return { type: newUnion, node };
+                return { type: newUnion };
             }
         }
         // Optional checks apply to all operations except for boolean operations.
@@ -7984,7 +7962,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             type = types_1.UnknownType.create();
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function customMetaclassSupportsMethod(type, methodName) {
         if (!(0, types_1.isInstantiableClass)(type)) {
@@ -8037,7 +8015,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const rightType = rightTypeResult.type;
         const isIncomplete = !!rightTypeResult.isIncomplete || !!leftTypeResult.isIncomplete;
         if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-            typeResult = { node, type: types_1.NeverType.createNever(), isIncomplete };
+            typeResult = { type: types_1.NeverType.createNever(), isIncomplete };
         }
         else {
             type = mapSubtypesExpandTypeVars(leftType, 
@@ -8085,7 +8063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 type = types_1.UnknownType.create();
             }
-            typeResult = { node, type, isIncomplete };
+            typeResult = { type, isIncomplete };
         }
         assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
         return typeResult;
@@ -8487,7 +8465,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (resultTypedDict) {
                     return {
                         type: resultTypedDict,
-                        node,
                         isIncomplete,
                     };
                 }
@@ -8525,7 +8502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const type = getBuiltInObject(node, 'dict', [specializedKeyType, specializedValueType]);
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     // Attempts to infer the type of a dictionary statement. If hasExpectedType
     // is true, strict inference is used for the subexpressions.
@@ -8569,7 +8546,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
@@ -8747,7 +8724,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const type = getBuiltInObject(node, builtInClassName, [specializedEntryType]);
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(node, hasExpectedType) {
@@ -8799,7 +8776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
         let targetTypeVar;
@@ -8861,7 +8838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
         }
-        return { type: (0, types_1.combineTypes)(typesToCombine), node, isIncomplete };
+        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete };
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -8891,7 +8868,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
         }
-        return { type: sentType || types_1.UnknownType.create(), node, isIncomplete };
+        return { type: sentType || types_1.UnknownType.create(), isIncomplete };
     }
     function getTypeOfYieldFrom(node) {
         var _a;
@@ -8914,7 +8891,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 returnedType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
             }
         }
-        return { type: returnedType || types_1.UnknownType.create(), node };
+        return { type: returnedType || types_1.UnknownType.create() };
     }
     function getTypeOfLambda(node, expectedType) {
         let isIncomplete = false;
@@ -9033,7 +9010,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        return { type: functionType, node, isIncomplete };
+        return { type: functionType, isIncomplete };
     }
     function getTypeOfListComprehension(node, expectedType) {
         let isIncomplete = false;
@@ -9066,7 +9043,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 : [elementType, types_1.NoneType.createInstance(), types_1.NoneType.createInstance()], 
             /* isTypeArgumentExplicit */ true));
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function reportPossibleUnknownAssignment(diagLevel, rule, target, type, errorNode, ignoreEmptyContainers) {
         // Don't bother if the feature is disabled.
@@ -9164,7 +9141,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             type = exprTypeResult.type;
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function getTypeOfSlice(node) {
         // Evaluate the expressions to report errors and record symbol
@@ -9180,7 +9157,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 getTypeOfExpression(node.stepValue);
             }
         }
-        return { type: getBuiltInObject(node, 'slice'), node };
+        return { type: getBuiltInObject(node, 'slice') };
     }
     // Verifies that a type argument's type is not disallowed.
     function validateTypeArg(argResult, options) {
@@ -9785,8 +9762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 });
             }
-            returnType = (0, typeUtils_1.specializeTupleClass)(classType, tupleTypeArgTypes, typeArgs !== undefined, 
-            /* stripLiterals */ false);
+            returnType = (0, typeUtils_1.specializeTupleClass)(classType, tupleTypeArgTypes, typeArgs !== undefined);
         }
         else {
             returnType = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
@@ -11573,8 +11549,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type, isUnbounded: !(0, types_1.isVariadicTypeVar)(type) }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true));
+                    /* isTypeArgumentExplicit */ true));
                 }
                 return types_1.UnknownType.create();
             }
@@ -12328,6 +12303,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
         writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
     }
+    function evaluateTypesForTypeAnnotationNode(node) {
+        var _a;
+        // If this node is part of an assignment statement, use specialized
+        // logic that performs bidirectional inference and assignment
+        // type narrowing.
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+            evaluateTypesForAssignmentStatement(node.parent);
+        }
+        else {
+            const annotationType = getTypeOfAnnotation(node.typeAnnotation, {
+                isVariableAnnotation: true,
+                allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
+                allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
+            });
+            writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+        }
+    }
     function getAliasedSymbolTypeForName(node, name) {
         const symbolWithScope = lookUpSymbolRecursive(node, name, /* honorCodeFlow */ true);
         if (!symbolWithScope) {
@@ -12388,62 +12380,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // allows for bidirectional type evaluation.
     function evaluateTypesForExpressionInContext(node) {
         var _a, _b, _c, _d, _e;
-        let lastContextualExpression = node;
-        let curNode = node;
-        function isContextual(node) {
-            var _a, _b, _c, _d, _e;
-            // Parameters are contextual only for lambdas.
-            if (node.nodeType === 41 /* Parameter */ && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 30 /* Lambda */) {
-                return true;
-            }
-            // Arguments are contextual only for call and index nodes.
-            if (node.nodeType === 1 /* Argument */ &&
-                (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 9 /* Call */ || ((_c = node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 24 /* Index */)) {
-                return true;
-            }
-            // All nodes within a type annotation need to be evaluated
-            // contextually so we pass the "type expected" flag to
-            // the evaluator.
-            if (((_d = node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* TypeAnnotation */) {
-                return true;
-            }
-            if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 41 /* Parameter */ &&
-                (node === node.parent.typeAnnotation || node === node.parent.typeAnnotationComment)) {
-                return true;
-            }
-            // The | operator is contextual in cases where it is used to describe a
-            // union in type annotations.
-            if (node.nodeType === 7 /* BinaryOperation */ && node.operator === 6 /* BitwiseOr */) {
-                return true;
-            }
-            return (node.nodeType === 9 /* Call */ ||
-                node.nodeType === 24 /* Index */ ||
-                node.nodeType === 15 /* Dictionary */ ||
-                node.nodeType === 27 /* FormatString */ ||
-                node.nodeType === 31 /* List */ ||
-                node.nodeType === 30 /* Lambda */ ||
-                node.nodeType === 35 /* MemberAccess */ ||
-                node.nodeType === 45 /* Set */ ||
-                node.nodeType === 49 /* String */ ||
-                node.nodeType === 48 /* StringList */ ||
-                node.nodeType === 52 /* Tuple */ ||
-                node.nodeType === 56 /* Unpack */ ||
-                node.nodeType === 17 /* DictionaryKeyEntry */ ||
-                node.nodeType === 16 /* DictionaryExpandEntry */ ||
-                node.nodeType === 32 /* ListComprehension */ ||
-                node.nodeType === 33 /* ListComprehensionFor */ ||
-                node.nodeType === 34 /* ListComprehensionIf */ ||
-                node.nodeType === 65 /* PatternSequence */ ||
-                node.nodeType === 67 /* PatternLiteral */ ||
-                node.nodeType === 68 /* PatternClass */ ||
-                node.nodeType === 74 /* PatternClassArgument */ ||
-                node.nodeType === 66 /* PatternAs */ ||
-                node.nodeType === 69 /* PatternCapture */ ||
-                node.nodeType === 70 /* PatternMapping */ ||
-                node.nodeType === 73 /* PatternValue */ ||
-                node.nodeType === 71 /* PatternMappingKeyEntry */ ||
-                node.nodeType === 72 /* PatternMappingExpandEntry */);
-        }
         // Check for a couple of special cases where the node is a NameNode but
         // is technically not part of an expression. We'll handle these here so
         // callers don't need to include special-case logic.
@@ -12452,154 +12388,228 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 getTypeOfFunction(node.parent);
                 return;
             }
-            else if (node.parent.nodeType === 10 /* Class */ && node.parent.name === node) {
+            if (node.parent.nodeType === 10 /* Class */ && node.parent.name === node) {
                 getTypeOfClass(node.parent);
                 return;
             }
-            else if (node.parent.nodeType === 77 /* TypeAlias */ && node.parent.name === node) {
+            if (node.parent.nodeType === 77 /* TypeAlias */ && node.parent.name === node) {
                 getTypeOfTypeAlias(node.parent);
                 return;
             }
-            else if (node.parent.nodeType === 29 /* Global */ ||
-                node.parent.nodeType === 39 /* Nonlocal */) {
+            if (node.parent.nodeType === 29 /* Global */ || node.parent.nodeType === 39 /* Nonlocal */) {
                 // For global and nonlocal statements, allow forward references so
                 // we don't use code flow during symbol lookups.
                 getTypeOfExpression(node, 4 /* AllowForwardReferences */);
                 return;
             }
+            if (node.parent.nodeType === 37 /* ModuleName */) {
+                // A name within a module name isn't an expression,
+                // so there's nothing we can evaluate here.
+                return;
+            }
         }
-        // Scan up the parse tree until we find a non-expression (while
-        // looking for contextual expressions in the process).
-        while (curNode) {
-            const isNodeContextual = isContextual(curNode);
-            if (!isNodeContextual && !(0, parseNodes_1.isExpressionNode)(curNode)) {
-                break;
+        // If the expression is part of a type annotation, we need to evaluate
+        // it with special evaluation flags.
+        const annotationNode = ParseTreeUtils.getParentAnnotationNode(node);
+        if (annotationNode) {
+            // Annotations need to be evaluated with specialized evaluation flags.
+            const annotationParent = annotationNode.parent;
+            (0, debug_1.assert)(annotationParent !== undefined);
+            if (annotationParent.nodeType === 3 /* Assignment */) {
+                if (annotationNode === annotationParent.typeAnnotationComment) {
+                    getTypeOfAnnotation(annotationNode, {
+                        isVariableAnnotation: true,
+                        allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(annotationParent.leftExpression),
+                        allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(annotationParent.leftExpression),
+                    });
+                }
+                else {
+                    evaluateTypesForAssignmentStatement(annotationParent);
+                }
+                return;
             }
-            if (isNodeContextual) {
-                lastContextualExpression = curNode;
+            if (annotationParent.nodeType === 54 /* TypeAnnotation */) {
+                evaluateTypesForTypeAnnotationNode(annotationParent);
+                return;
             }
-            curNode = curNode.parent;
-        }
-        const parent = lastContextualExpression.parent;
-        if (parent.nodeType === 3 /* Assignment */) {
-            if (lastContextualExpression === parent.typeAnnotationComment) {
-                getTypeOfAnnotation(lastContextualExpression, {
-                    isVariableAnnotation: true,
-                    allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(parent.leftExpression),
-                    allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(parent.leftExpression),
+            if (annotationParent.nodeType === 28 /* Function */ &&
+                annotationNode === annotationParent.returnTypeAnnotation) {
+                getTypeOfAnnotation(annotationNode, {
+                    associateTypeVarsWithScope: true,
+                    disallowRecursiveTypeAlias: true,
                 });
+                return;
             }
-            else {
-                evaluateTypesForAssignmentStatement(parent);
-            }
-            return;
-        }
-        else if (parent.nodeType === 14 /* Del */) {
-            verifyDeleteExpression(lastContextualExpression);
+            getTypeOfAnnotation(annotationNode);
             return;
         }
-        // If this is the name node within a type parameter list, see if it's a type alias
-        // definition. If so, we need to evaluate the type alias contextually.
-        if (parent.nodeType === 75 /* TypeParameter */ && lastContextualExpression === parent.name) {
-            if (((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 76 /* TypeParameterList */ &&
-                ((_b = parent.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 77 /* TypeAlias */) {
-                getTypeOfTypeAlias(parent.parent.parent);
+        // See if the expression is part of a pattern used in a case statement.
+        const possibleCaseNode = ParseTreeUtils.getParentNodeOfType(node, 64 /* Case */);
+        if (possibleCaseNode) {
+            const caseNode = possibleCaseNode;
+            if (ParseTreeUtils.isNodeContainedWithin(node, caseNode.pattern)) {
+                evaluateTypesForCaseStatement(caseNode);
                 return;
             }
         }
-        if (parent.nodeType === 75 /* TypeParameter */) {
-            getTypeOfExpression(parent.name);
-            return;
-        }
-        if (parent.nodeType === 77 /* TypeAlias */) {
-            getTypeOfTypeAlias(parent);
-            return;
-        }
-        if (parent.nodeType === 5 /* AugmentedAssignment */) {
-            evaluateTypesForAugmentedAssignment(parent);
-            return;
-        }
-        if (parent.nodeType === 13 /* Decorator */) {
-            if (((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
-                getTypeOfClass(parent.parent);
+        // Scan up the parse tree until we find a node that doesn't
+        // require any context to be evaluated.
+        let nodeToEvaluate = node;
+        let flags = 0 /* None */;
+        while (true) {
+            // If we're within an argument node in a call or index expression, skip
+            // all of the nodes between because the entire argument expression
+            // needs to be evaluated contextually.
+            const argumentNode = ParseTreeUtils.getParentNodeOfType(nodeToEvaluate, 1 /* Argument */);
+            if (argumentNode && argumentNode !== nodeToEvaluate) {
+                (0, debug_1.assert)(argumentNode.parent !== undefined);
+                if (argumentNode.parent.nodeType === 9 /* Call */ ||
+                    argumentNode.parent.nodeType === 24 /* Index */) {
+                    nodeToEvaluate = argumentNode.parent;
+                    continue;
+                }
             }
-            else if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 28 /* Function */) {
-                getTypeOfFunction(parent.parent);
+            let parent = nodeToEvaluate.parent;
+            if (!parent) {
+                break;
             }
-            return;
-        }
-        const evaluateTypeAnnotationExpression = (node) => {
-            const annotationParent = node.parent;
-            if ((annotationParent === null || annotationParent === void 0 ? void 0 : annotationParent.nodeType) === 3 /* Assignment */ && annotationParent.leftExpression === parent) {
-                evaluateTypesForAssignmentStatement(annotationParent);
+            // If this is the target of an assignment expression, evaluate the
+            // assignment expression node instead.
+            if (parent.nodeType === 4 /* AssignmentExpression */ && nodeToEvaluate === parent.name) {
+                nodeToEvaluate = parent;
+                continue;
+            }
+            // The left expression of a call or member access expression is not contextual.
+            if (parent.nodeType === 9 /* Call */ || parent.nodeType === 35 /* MemberAccess */) {
+                if (nodeToEvaluate === parent.leftExpression) {
+                    flags = 2 /* DoNotSpecialize */;
+                    break;
+                }
+            }
+            else if (parent.nodeType === 24 /* Index */) {
+                // The base expression of an index expression is not contextual.
+                if (nodeToEvaluate === parent.baseExpression) {
+                    flags = 2 /* DoNotSpecialize */;
+                    break;
+                }
             }
             else {
-                const annotationType = getTypeOfAnnotation(node.typeAnnotation, {
-                    isVariableAnnotation: true,
-                    allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
-                    allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
-                });
-                writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+                // Check for expression types that are always contextual.
+                if (nodeToEvaluate.nodeType !== 15 /* Dictionary */ &&
+                    nodeToEvaluate.nodeType !== 31 /* List */ &&
+                    nodeToEvaluate.nodeType !== 30 /* Lambda */ &&
+                    nodeToEvaluate.nodeType !== 45 /* Set */ &&
+                    nodeToEvaluate.nodeType !== 52 /* Tuple */ &&
+                    nodeToEvaluate.nodeType !== 56 /* Unpack */ &&
+                    nodeToEvaluate.nodeType !== 32 /* ListComprehension */) {
+                    break;
+                }
             }
-        };
-        if (parent.nodeType === 64 /* Case */ && lastContextualExpression !== parent.guardExpression) {
-            evaluateTypesForCaseStatement(parent);
-            return;
-        }
-        if (parent.nodeType === 54 /* TypeAnnotation */) {
-            evaluateTypeAnnotationExpression(parent);
-            return;
-        }
-        if (parent.nodeType === 41 /* Parameter */ && lastContextualExpression !== parent.defaultValue) {
-            evaluateTypeOfParameter(parent);
-            return;
+            if (!(0, parseNodes_1.isExpressionNode)(parent)) {
+                // If we've hit a non-expression node, we generally want to
+                // stop. However, there are a few special "pass through"
+                // node types that we can skip over to get to a known
+                // expression node.
+                if (parent.nodeType === 17 /* DictionaryKeyEntry */ ||
+                    parent.nodeType === 16 /* DictionaryExpandEntry */ ||
+                    parent.nodeType === 33 /* ListComprehensionFor */ ||
+                    parent.nodeType === 34 /* ListComprehensionIf */) {
+                    (0, debug_1.assert)(parent.parent !== undefined && (0, parseNodes_1.isExpressionNode)(parent.parent));
+                    parent = parent.parent;
+                }
+                else if (parent.nodeType === 41 /* Parameter */) {
+                    (0, debug_1.assert)(parent.parent !== undefined);
+                    // Parameters are contextual for lambdas.
+                    if (parent.parent.nodeType === 30 /* Lambda */) {
+                        parent = parent.parent;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            nodeToEvaluate = parent;
         }
-        if (parent.nodeType === 28 /* Function */) {
-            if (lastContextualExpression === parent.returnTypeAnnotation) {
-                getTypeOfAnnotation(lastContextualExpression, {
-                    associateTypeVarsWithScope: true,
-                    disallowRecursiveTypeAlias: true,
-                });
+        const parent = nodeToEvaluate.parent;
+        (0, debug_1.assert)(parent !== undefined);
+        switch (parent.nodeType) {
+            case 14 /* Del */: {
+                verifyDeleteExpression(nodeToEvaluate);
+                return;
+            }
+            case 75 /* TypeParameter */: {
+                // If this is the name node within a type parameter list, see if it's a type alias
+                // definition. If so, we need to evaluate the type alias contextually.
+                if (nodeToEvaluate === parent.name &&
+                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 76 /* TypeParameterList */ &&
+                    ((_b = parent.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 77 /* TypeAlias */) {
+                    getTypeOfTypeAlias(parent.parent.parent);
+                    return;
+                }
+                break;
+            }
+            case 77 /* TypeAlias */: {
+                getTypeOfTypeAlias(parent);
+                return;
+            }
+            case 13 /* Decorator */: {
+                if (((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+                    getTypeOfClass(parent.parent);
+                }
+                else if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 28 /* Function */) {
+                    getTypeOfFunction(parent.parent);
+                }
+                return;
+            }
+            case 41 /* Parameter */: {
+                if (nodeToEvaluate !== parent.defaultValue) {
+                    evaluateTypeOfParameter(parent);
+                    return;
+                }
+                break;
+            }
+            case 1 /* Argument */: {
+                if (nodeToEvaluate === parent.name) {
+                    // A name used to specify a named parameter in an argument isn't an
+                    // expression, so there's nothing we can evaluate here.
+                    return;
+                }
+                if (((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 10 /* Class */) {
+                    // A class argument must be evaluated in the context of the class declaration.
+                    getTypeOfClass(parent.parent);
+                    return;
+                }
+                break;
+            }
+            case 44 /* Return */: {
+                // Return expressions must be evaluated in the context of the expected return type.
+                if (parent.returnExpression) {
+                    const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
+                    const declaredReturnType = enclosingFunctionNode
+                        ? getFunctionDeclaredReturnType(enclosingFunctionNode)
+                        : undefined;
+                    getTypeOfExpression(parent.returnExpression, 0 /* None */, declaredReturnType);
+                    return;
+                }
+                break;
+            }
+            case 54 /* TypeAnnotation */: {
+                evaluateTypesForTypeAnnotationNode(parent);
+                return;
+            }
+            case 3 /* Assignment */: {
+                evaluateTypesForAssignmentStatement(parent);
                 return;
             }
         }
-        if (parent.nodeType === 37 /* ModuleName */) {
-            // A name within a module name isn't an expression,
-            // so there's nothing we can evaluate here.
-            return;
-        }
-        if (parent.nodeType === 1 /* Argument */ && lastContextualExpression === parent.name) {
-            // A name used to specify a named parameter in an argument isn't an
-            // expression, so there's nothing we can evaluate here.
-            return;
-        }
-        // A class argument must be evaluated in the context of the class declaration.
-        if (parent.nodeType === 1 /* Argument */ && ((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 10 /* Class */) {
-            getTypeOfClass(parent.parent);
-            return;
-        }
-        if (parent.nodeType === 44 /* Return */ && parent.returnExpression) {
-            const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-            const declaredReturnType = enclosingFunctionNode
-                ? getFunctionDeclaredReturnType(enclosingFunctionNode)
-                : undefined;
-            getTypeOfExpression(parent.returnExpression, 0 /* None */, declaredReturnType);
-            return;
-        }
-        // If the parent is an expression, we'll evaluate it to provide
-        // the context for its child. If it's not, we'll evaluate the
-        // child directly without any context.
-        const nodeToEvaluate = (0, parseNodes_1.isExpressionNode)(parent) && parent.nodeType !== 0 /* Error */
-            ? parent
-            : lastContextualExpression;
         if (nodeToEvaluate.nodeType === 54 /* TypeAnnotation */) {
-            evaluateTypeAnnotationExpression(nodeToEvaluate);
-        }
-        else {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(nodeToEvaluate);
-            const flags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-            getTypeOfExpression(nodeToEvaluate, flags);
+            evaluateTypesForTypeAnnotationNode(nodeToEvaluate);
+            return;
         }
+        getTypeOfExpression(nodeToEvaluate, flags);
     }
     function evaluateTypeOfParameter(node) {
         // If this parameter has no name, we have nothing to do.
@@ -12759,7 +12769,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // doing additional work.
         let subnodeType = readTypeCache(subnode, /* flags */ undefined);
         if (subnodeType) {
-            return { node: subnode, type: subnodeType };
+            return { type: subnodeType };
         }
         const oldIncompleteCache = incompleteTypeCache;
         try {
@@ -12772,11 +12782,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             callback();
             subnodeType = readTypeCache(subnode, /* flags */ undefined);
             if (subnodeType) {
-                return { node: subnode, type: subnodeType };
+                return { type: subnodeType };
             }
             subnodeType = incompleteTypeCache.get(subnode.id);
             if (subnodeType) {
-                return { node: subnode, type: subnodeType, isIncomplete: true };
+                return { type: subnodeType, isIncomplete: true };
             }
             incompleteTypeCache = oldIncompleteCache;
         }
@@ -14442,7 +14452,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // prior to specializing.
                 inferReturnTypeIfNecessary(typeResult.type);
                 return {
-                    node,
                     type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, selfClass),
                     isIncomplete: !!typeResult.isIncomplete,
                 };
@@ -14625,7 +14634,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return { type: (0, typeUtils_1.stripLiteralValue)(typeArg.type), isUnbounded: false };
                         }), 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         srcTypeArgs.splice(destVariadicIndex, 0, {
                             type: variadicTuple,
@@ -15549,54 +15557,69 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // For union destinations, we just need to match one of the types.
         const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         let foundMatch = false;
-        // Run through all subtypes in the union. Don't stop at the first
-        // match we find because we may need to match TypeVars in other
-        // subtypes. We special-case "None" so we can handle Optional[T]
-        // without matching the None to the type var.
-        if ((0, types_1.isNoneInstance)(srcType) && (0, typeUtils_1.isOptionalType)(destType)) {
-            foundMatch = true;
+        // Does the union contain any type variables that need to be solved?
+        // If so, we need to use a slower path.
+        if (!(0, typeUtils_1.requiresSpecialization)(destType)) {
+            for (const subtype of destType.subtypes) {
+                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), 
+                /* destTypeVarContextClone */ undefined, 
+                /* srcTypeVarContextClone */ undefined, flags, recursionCount)) {
+                    foundMatch = true;
+                    break;
+                }
+            }
         }
         else {
-            let bestDestTypeVarContext;
-            let bestSrcTypeVarContext;
-            let bestTypeVarContextScore;
-            // If the srcType is a literal, try to use the fast-path lookup
-            // in case the destType is a union with hundreds of literals.
-            if ((0, types_1.isClassInstance)(srcType) &&
-                (0, typeUtils_1.isLiteralType)(srcType) &&
-                types_1.UnionType.containsType(destType, srcType, recursionCount)) {
-                return true;
+            // Run through all subtypes in the union. Don't stop at the first
+            // match we find because we may need to match TypeVars in other
+            // subtypes. We special-case "None" so we can handle Optional[T]
+            // without matching the None to the type var.
+            if ((0, types_1.isNoneInstance)(srcType) && (0, typeUtils_1.isOptionalType)(destType)) {
+                foundMatch = true;
             }
-            (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
-                // Make a temporary clone of the typeVarContext. We don't want to modify
-                // the original typeVarContext until we find the "optimal" typeVar mapping.
-                const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
-                const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
-                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
-                    foundMatch = true;
-                    if (destTypeVarContextClone) {
-                        // Ask the typeVarContext to compute a "score" for the current
-                        // contents of the table.
-                        let typeVarContextScore = destTypeVarContextClone.getScore();
-                        // If the type matches exactly, prefer it over other types.
-                        if ((0, types_1.isTypeSame)(subtype, (0, typeUtils_1.stripLiteralValue)(srcType))) {
-                            typeVarContextScore = Number.POSITIVE_INFINITY;
-                        }
-                        if (bestTypeVarContextScore === undefined || bestTypeVarContextScore <= typeVarContextScore) {
-                            // We found a typeVar mapping with a higher score than before.
-                            bestTypeVarContextScore = typeVarContextScore;
-                            bestDestTypeVarContext = destTypeVarContextClone;
-                            bestSrcTypeVarContext = srcTypeVarContextClone;
+            else {
+                let bestDestTypeVarContext;
+                let bestSrcTypeVarContext;
+                let bestTypeVarContextScore;
+                // If the srcType is a literal, try to use the fast-path lookup
+                // in case the destType is a union with hundreds of literals.
+                if ((0, types_1.isClassInstance)(srcType) &&
+                    (0, typeUtils_1.isLiteralType)(srcType) &&
+                    types_1.UnionType.containsType(destType, srcType, recursionCount)) {
+                    return true;
+                }
+                (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
+                    // Make a temporary clone of the typeVarContext. We don't want to modify
+                    // the original typeVarContext until we find the "optimal" typeVar mapping.
+                    const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
+                    const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
+                    if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
+                        foundMatch = true;
+                        if (destTypeVarContextClone) {
+                            // Ask the typeVarContext to compute a "score" for the current
+                            // contents of the table.
+                            let typeVarContextScore = destTypeVarContextClone.getScore();
+                            // If the type matches exactly, prefer it over other types.
+                            if ((0, types_1.isTypeSame)(subtype, (0, typeUtils_1.stripLiteralValue)(srcType))) {
+                                typeVarContextScore = Number.POSITIVE_INFINITY;
+                            }
+                            if (bestTypeVarContextScore === undefined ||
+                                bestTypeVarContextScore <= typeVarContextScore) {
+                                // We found a typeVar mapping with a higher score than before.
+                                bestTypeVarContextScore = typeVarContextScore;
+                                bestDestTypeVarContext = destTypeVarContextClone;
+                                bestSrcTypeVarContext = srcTypeVarContextClone;
+                            }
                         }
                     }
+                });
+                // If we found a winning type var mapping, copy it back to typeVarContext.
+                if (destTypeVarContext && bestDestTypeVarContext) {
+                    destTypeVarContext.copyFromClone(bestDestTypeVarContext);
+                }
+                if (srcTypeVarContext && bestSrcTypeVarContext) {
+                    srcTypeVarContext.copyFromClone(bestSrcTypeVarContext);
                 }
-            });
-            // If we found a winning type var mapping, copy it back to typeVarContext.
-            if (destTypeVarContext && bestDestTypeVarContext) {
-                destTypeVarContext.copyFromClone(bestDestTypeVarContext);
-            }
-            if (srcTypeVarContext && bestSrcTypeVarContext) {
-                srcTypeVarContext.copyFromClone(bestSrcTypeVarContext);
             }
         }
         // If the source is a constrained TypeVar, see if we can assign all of the
@@ -15884,7 +15907,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                 srcPositionalsType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, srcTupleTypes, 
                 /* isTypeArgumentExplicit */ true, 
-                /* stripLiterals */ true, 
                 /* isUnpackedTuple */ true));
             }
             else {
@@ -16070,13 +16092,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                 if (!(0, types_1.isUnpacked)(destArgsType)) {
                     destArgsType = types_1.ClassType.cloneForUnpacked(types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: destArgsType, isUnbounded: true }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true)));
+                    /* isTypeArgumentExplicit */ true)));
                 }
                 if (!(0, types_1.isUnpacked)(srcArgsType)) {
                     srcArgsType = types_1.ClassType.cloneForUnpacked(types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: srcArgsType, isUnbounded: true }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true)));
+                    /* isTypeArgumentExplicit */ true)));
                 }
             }
             if (!assignFunctionParameter(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {