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

package/dist/analyzer/typeEvaluator.js

@@ -188,6 +188,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
     let isPrefetchedTypesInitialized = false;
+    const signatureTrackerStack = [];
     // Various types prefetched from stdlib stubs
     let noneTypeClass;
     let objectClass;
@@ -500,7 +501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext, signatureTracker) {
+    function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -538,7 +539,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // needed in assignType, but we don't have access to the parse tree
         // at that point.
         initializePrefetchedTypes(node);
-        let typeResult = getTypeOfExpressionCore(node, flags, inferenceContext, signatureTracker);
+        let typeResult = getTypeOfExpressionCore(node, flags, inferenceContext);
         // Should we disable type promotions for bytes?
         if ((0, types_1.isInstantiableClass)(typeResult.type) &&
             typeResult.type.priv.includePromotions &&
@@ -555,16 +556,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // the target name node won't have a corresponding type cached speculatively.
         const allowSpeculativeCaching = node.nodeType !== 4 /* ParseNodeType.AssignmentExpression */;
         writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching);
+        if (node.nodeType === 38 /* ParseNodeType.Name */ || node.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+            // If this is a generic function and there is a signature tracker,
+            // make sure the signature is unique.
+            typeResult.type = ensureSignatureIsUnique(typeResult.type, node);
+        }
         // If there was an expected type, make sure that the result type is compatible.
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
             !(0, types_1.isNever)(inferenceContext.expectedType)) {
             expectedTypeCache.set(node.id, inferenceContext.expectedType);
-            // If this is a generic function and there is a signature tracker,
-            // make sure the signature is unique.
-            if (signatureTracker && (0, types_1.isFunction)(typeResult.type)) {
-                typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, node.start);
-            }
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
@@ -584,7 +585,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeResult;
     }
     // This is a helper function that implements the core of getTypeOfExpression.
-    function getTypeOfExpressionCore(node, flags = 0 /* EvalFlags.None */, inferenceContext, signatureTracker) {
+    function getTypeOfExpressionCore(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
         var _a;
         let typeResult;
         let expectingInstantiable = (flags & 128 /* EvalFlags.InstantiableType */) !== 0;
@@ -602,11 +603,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 9 /* ParseNodeType.Call */: {
-                typeResult = getTypeOfCall(node, flags, inferenceContext, signatureTracker);
+                typeResult = useSignatureTracker(node, () => getTypeOfCall(node, flags, inferenceContext));
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                typeResult = getTypeOfTuple(node, flags, inferenceContext, signatureTracker);
+                typeResult = getTypeOfTuple(node, flags, inferenceContext);
                 break;
             }
             case 14 /* ParseNodeType.Constant */: {
@@ -679,7 +680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 3 /* ParseNodeType.Assignment */: {
-                typeResult = getTypeOfExpression(node.d.rightExpr, flags, inferenceContext, signatureTracker);
+                typeResult = getTypeOfExpression(node.d.rightExpr, flags, inferenceContext);
                 assignTypeToExpression(node.d.leftExpr, typeResult, node.d.rightExpr, 
                 /* ignoreEmptyContainers */ true, 
                 /* allowAssignmentToFinalVar */ true);
@@ -687,9 +688,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
                 if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-                    addError(localize_1.LocMessage.walrusNotAllowed(), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.walrusNotAllowed(), node);
                 }
-                typeResult = getTypeOfExpression(node.d.rightExpr, flags, inferenceContext, signatureTracker);
+                typeResult = getTypeOfExpression(node.d.rightExpr, flags, inferenceContext);
                 assignTypeToExpression(node.d.name, typeResult, node.d.rightExpr, /* ignoreEmptyContainers */ true);
                 break;
             }
@@ -778,7 +779,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) !== 0) {
             if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.priv.isVariadicInUnion) {
-                addError(localize_1.LocMessage.typeVarTupleContext(), node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), node);
                 typeResult.type = types_1.UnknownType.create();
             }
         }
@@ -803,7 +804,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
         if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-            addError(localize_1.LocMessage.awaitNotAllowed(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.awaitNotAllowed(), node);
             return { type: types_1.UnknownType.create() };
         }
         const expectedType = inferenceContext
@@ -869,7 +870,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
         }
         else if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-            addError(localize_1.LocMessage.unpackInAnnotation(), node, node.d.starToken);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackInAnnotation(), node, node.d.starToken);
             typeResult = { type: types_1.UnknownType.create() };
         }
         else {
@@ -1118,6 +1119,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo)) {
             evaluatorFlags |= 4 /* EvalFlags.ForwardRefs */;
         }
+        if (options === null || options === void 0 ? void 0 : options.enforceClassTypeVarScope) {
+            evaluatorFlags |= 1073741824 /* EvalFlags.EnforceClassTypeVarScope */;
+        }
         // If the annotation is part of a comment, allow forward references
         // even if it's not enclosed in quotes.
         if (((_a = node === null || node === void 0 ? void 0 : node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */ && node.parent.d.annotationComment === node) {
@@ -1561,8 +1565,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             useSpeculativeMode(callNode, () => {
                 callResult = validateArgs(exprNode, argList, { type }, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type)), 
                 /* skipUnknownArgCheck */ true, 
-                /* inferenceContext */ undefined, 
-                /* signatureTracker */ undefined);
+                /* inferenceContext */ undefined);
             });
             signatures.push({
                 type: expandTypedKwargs(type),
@@ -1781,7 +1784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (classOrObjectBase) {
                     if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
-                        declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass);
+                        declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType());
                     }
                     if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloadedFunction)(declaredType)) {
                         if (bindFunction) {
@@ -2010,6 +2013,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getUnionClassType() {
         return unionTypeClass !== null && unionTypeClass !== void 0 ? unionTypeClass : types_1.UnknownType.create();
     }
+    function getTypeClassType() {
+        if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
+            return typeClass;
+        }
+        return undefined;
+    }
     function getTypingType(node, symbolName) {
         var _a;
         return ((_a = getTypeOfModule(node, symbolName, ['typing'])) !== null && _a !== void 0 ? _a : getTypeOfModule(node, symbolName, ['typing_extensions']));
@@ -2123,9 +2132,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function addInformation(message, node, range) {
         return addDiagnosticWithSuppressionCheck('information', message, node, range);
     }
-    function addError(message, node, range) {
-        return addDiagnosticWithSuppressionCheck('error', message, node, range);
-    }
     function addUnusedCode(node, textRange) {
         if (!isDiagnosticSuppressedForNode(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -2307,6 +2313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a;
         const baseTypeResult = getTypeOfExpression(target.d.leftExpr, 2 /* EvalFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
+        let enclosingClass;
         // Handle member accesses (e.g. self.x or cls.y).
         if (target.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */) {
             // Determine whether we're writing to a class or instance member.
@@ -2314,6 +2321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (enclosingClassNode) {
                 const classTypeResults = getTypeOfClass(enclosingClassNode);
                 if (classTypeResults && (0, types_1.isInstantiableClass)(classTypeResults.classType)) {
+                    enclosingClass = classTypeResults.classType;
                     if ((0, types_1.isClassInstance)(baseType)) {
                         if (types_1.ClassType.isSameGenericClass(baseType, classTypeResults.classType)) {
                             assignTypeToMemberVariable(target, typeResult, /* isInstanceMember */ true, srcExpr);
@@ -2333,7 +2341,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 return !ParseTreeUtils.getEnclosingFunction(decl.node);
                             });
                             if (classLevelDecls.length === 0) {
-                                addError(localize_1.LocMessage.assignmentInProtocol(), target.d.member);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.assignmentInProtocol(), target.d.member);
                             }
                         }
                     }
@@ -2354,8 +2362,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isIncomplete: typeResult.isIncomplete,
             memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
         };
-        writeTypeCache(target.d.member, resultToCache, 0 /* EvalFlags.None */);
         writeTypeCache(target, resultToCache, 0 /* EvalFlags.None */);
+        // If the target is an instance or class variable, update any class-scoped
+        // type variables so the inferred type of the variable uses "external"
+        // type variables.
+        let memberResultToCache = resultToCache;
+        if (enclosingClass === null || enclosingClass === void 0 ? void 0 : enclosingClass.shared.typeVarScopeId) {
+            memberResultToCache = {
+                ...resultToCache,
+                type: (0, typeUtils_1.updateTypeWithExternalTypeVars)(resultToCache.type, [enclosingClass.shared.typeVarScopeId]),
+            };
+        }
+        writeTypeCache(target.d.member, memberResultToCache, 0 /* EvalFlags.None */);
     }
     function assignTypeToMemberVariable(node, typeResult, isInstanceMember, srcExprNode) {
         var _a;
@@ -2636,6 +2654,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 // Fall back to a bound of "object" if no bound is provided.
                 let boundType = (_a = subtype.shared.boundType) !== null && _a !== void 0 ? _a : getObjectType();
+                // If this is a synthesized self/cls type var, self-specialize its type arguments.
+                if (subtype.shared.isSynthesizedSelf && (0, types_1.isClass)(boundType)) {
+                    boundType = (0, typeUtils_1.selfSpecializeClass)(boundType, {
+                        useInternalTypeVars: types_1.TypeVarType.hasInternalScopeId(subtype),
+                    });
+                }
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
                 return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
             }
@@ -2767,7 +2791,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const typeVarTarget = target.nodeType === 54 /* ParseNodeType.TypeAnnotation */ ? target.d.valueExpr : target;
                     if (typeVarTarget.nodeType !== 38 /* ParseNodeType.Name */ ||
                         typeVarTarget.d.value !== typeResult.type.shared.name) {
-                        addError(typeResult.type.shared.isParamSpec
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, typeResult.type.shared.isParamSpec
                             ? localize_1.LocMessage.paramSpecAssignedName().format({
                                 name: types_1.TypeVarType.getReadableName(typeResult.type),
                             })
@@ -2854,7 +2878,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             default: {
-                addError(localize_1.LocMessage.assignmentTargetExpr(), target);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.assignmentTargetExpr(), target);
                 break;
             }
         }
@@ -2883,8 +2907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 suppressDiagnostics(node.d.typeExpression, () => {
                                     callResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, node.d.typeExpression, [], concreteSubtype, 
                                     /* skipUnknownArgCheck */ false, 
-                                    /* inferenceContext */ undefined, 
-                                    /* signatureTracker */ undefined);
+                                    /* inferenceContext */ undefined);
                                 });
                                 if (callResult && callResult.argumentErrors) {
                                     diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeNotInstantiable().format({
@@ -3079,7 +3102,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((0, types_1.isParamSpec)(type)) {
             if (flags & 32 /* EvalFlags.NoParamSpec */) {
-                addError(localize_1.LocMessage.paramSpecContext(), node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
             }
         }
@@ -3221,89 +3244,137 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // cannot be used in this location.
     function validateTypeVarUsage(node, type, flags) {
         var _a;
-        if (types_1.TypeBase.isInstantiable(type) && !type.priv.scopeId && !(0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
-            const scopedTypeVarInfo = findScopedTypeVar(node, type);
-            type = scopedTypeVarInfo.type;
-            if ((flags & 2048 /* EvalFlags.NoTypeVarWithScopeId */) !== 0 && type.priv.scopeId !== undefined) {
-                if (!type.shared.isSynthesized && !type.shared.isParamSpec) {
-                    // This TypeVar already has a scope ID assigned to it. See if it
-                    // originates from type parameter syntax. If so, allow it.
-                    if (type.shared.isTypeParamSyntax) {
-                        return type;
-                    }
-                    // If this type variable expression is used within a generic class,
-                    // function, or type alias that uses type parameter syntax, there is
-                    // no need to report an error here.
-                    const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(node);
-                    if (typeVarScopeNode &&
-                        typeVarScopeNode.d.typeParams &&
-                        !typeVarScopeNode.d.typeParams.d.params.some((t) => t.d.name === node)) {
-                        return type;
-                    }
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.shared.name }), node);
-                }
-            }
-            else if ((flags & 8192 /* EvalFlags.TypeVarGetsCurScope */) !== 0) {
-                if (type.priv.scopeId === undefined) {
-                    if (!scopedTypeVarInfo.foundInterveningClass) {
-                        let enclosingScope = ParseTreeUtils.getEnclosingClassOrFunction(node);
-                        // Handle P.args and P.kwargs as a special case for inner functions.
-                        if (enclosingScope &&
-                            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
-                            node.parent.d.leftExpr === node) {
-                            const memberName = node.parent.d.member.d.value;
-                            if (memberName === 'args' || memberName === 'kwargs') {
-                                const outerFunctionScope = ParseTreeUtils.getEnclosingClassOrFunction(enclosingScope);
-                                if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 31 /* ParseNodeType.Function */) {
-                                    enclosingScope = outerFunctionScope;
-                                }
-                                else if (!scopedTypeVarInfo.type.priv.scopeId) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecNotUsedByOuterScope().format({
-                                        name: type.shared.name,
-                                    }), node);
-                                }
-                            }
-                        }
-                        if (enclosingScope) {
-                            // If the enclosing scope is using type parameter syntax, traditional
-                            // type variables can't be used in this context.
-                            if (enclosingScope.d.typeParams &&
-                                !enclosingScope.d.typeParams.d.params.some((param) => param.d.name.d.value === type.shared.name)) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
-                                    name: type.shared.name,
-                                    container: enclosingScope.d.name.d.value,
-                                }), node);
-                            }
-                            type = types_1.TypeVarType.cloneForScopeId(type, ParseTreeUtils.getScopeIdForNode(enclosingScope), enclosingScope.d.name.d.value, enclosingScope.nodeType === 31 /* ParseNodeType.Function */
-                                ? 1 /* TypeVarScopeType.Function */
-                                : 0 /* TypeVarScopeType.Class */);
-                        }
-                        else {
-                            (0, debug_1.fail)('AssociateTypeVarsWithCurrentScope flag was set but enclosing scope not found');
-                        }
-                    }
-                    else {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.shared.name }), node);
+        if (!types_1.TypeBase.isInstantiable(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+            return type;
+        }
+        // If the TypeVar doesn't have a scope ID, try to assign one.
+        if (!type.priv.scopeId) {
+            type = assignTypeVarScopeId(node, type, flags);
+        }
+        // If this TypeVar has an external scope ID, see if we need to
+        // make it into an internal scope ID instead.
+        if (type.priv.scopeId && !types_1.TypeVarType.hasInternalScopeId(type)) {
+            // If this is a reference to a TypeVar defined in an outer scope,
+            // change it to have an internal scope ID.
+            const scopedNode = (_a = findScopedTypeVar(node, type)) === null || _a === void 0 ? void 0 : _a.scopeNode;
+            if (scopedNode) {
+                const enclosingSuite = ParseTreeUtils.getEnclosingClassOrFunctionSuite(node);
+                if (enclosingSuite && ParseTreeUtils.isNodeContainedWithin(enclosingSuite, scopedNode)) {
+                    if (scopedNode.nodeType !== 10 /* ParseNodeType.Class */ || scopedNode.d.suite !== enclosingSuite) {
+                        type = types_1.TypeVarType.cloneWithInternalScopeId(type);
                     }
                 }
             }
-            else if ((flags & 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */) === 0) {
-                if ((type.priv.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
-                    !type.shared.isSynthesized) {
-                    const message = (0, types_1.isParamSpec)(type)
-                        ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
-                        : localize_1.LocMessage.typeVarNotUsedByOuterScope();
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.shared.name }), node);
-                }
-            }
         }
         // If this type var is variadic, the name refers to the packed form. It
         // must be unpacked in most contexts.
         if ((0, types_1.isUnpackedVariadicTypeVar)(type)) {
             type = types_1.TypeVarType.cloneForPacked(type);
         }
+        if ((flags & 1073741824 /* EvalFlags.EnforceClassTypeVarScope */) !== 0 && !enforceClassTypeVarScope(node, type)) {
+            return types_1.UnknownType.create();
+        }
         return type;
     }
+    function assignTypeVarScopeId(node, type, flags) {
+        var _a;
+        const scopedTypeVarInfo = findScopedTypeVar(node, type);
+        type = scopedTypeVarInfo.type;
+        if ((flags & 2048 /* EvalFlags.NoTypeVarWithScopeId */) !== 0 && !!type.priv.scopeId) {
+            if (type.shared.isSynthesized || type.shared.isParamSpec) {
+                return type;
+            }
+            // This TypeVar already has a scope ID assigned to it. See if it
+            // originates from type parameter syntax. If so, allow it.
+            if (type.shared.isTypeParamSyntax) {
+                return type;
+            }
+            // If this type variable expression is used within a generic class,
+            // function, or type alias that uses type parameter syntax, there is
+            // no need to report an error here.
+            const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(node);
+            if (typeVarScopeNode &&
+                typeVarScopeNode.d.typeParams &&
+                !typeVarScopeNode.d.typeParams.d.params.some((t) => t.d.name === node)) {
+                return type;
+            }
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.shared.name }), node);
+            return type;
+        }
+        if ((flags & 8192 /* EvalFlags.TypeVarGetsCurScope */) !== 0) {
+            if (type.priv.scopeId) {
+                return type;
+            }
+            if (scopedTypeVarInfo.foundInterveningClass) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.shared.name }), node);
+                return type;
+            }
+            let enclosingScope = ParseTreeUtils.getEnclosingClassOrFunction(node);
+            // Handle P.args and P.kwargs as a special case for inner functions.
+            if (enclosingScope &&
+                ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
+                node.parent.d.leftExpr === node) {
+                const memberName = node.parent.d.member.d.value;
+                if (memberName === 'args' || memberName === 'kwargs') {
+                    const outerFunctionScope = ParseTreeUtils.getEnclosingClassOrFunction(enclosingScope);
+                    if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 31 /* ParseNodeType.Function */) {
+                        enclosingScope = outerFunctionScope;
+                    }
+                    else if (!scopedTypeVarInfo.type.priv.scopeId) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecNotUsedByOuterScope().format({
+                            name: type.shared.name,
+                        }), node);
+                    }
+                }
+            }
+            if (!enclosingScope) {
+                (0, debug_1.fail)('AssociateTypeVarsWithCurrentScope flag was set but enclosing scope not found');
+            }
+            // If the enclosing scope is using type parameter syntax, traditional
+            // type variables can't be used in this context.
+            if (enclosingScope.d.typeParams &&
+                !enclosingScope.d.typeParams.d.params.some((param) => param.d.name.d.value === type.shared.name)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
+                    name: type.shared.name,
+                    container: enclosingScope.d.name.d.value,
+                }), node);
+            }
+            const scopeIdToAssign = ParseTreeUtils.getScopeIdForNode(enclosingScope);
+            return types_1.TypeVarType.cloneForScopeId(type, scopeIdToAssign, enclosingScope.d.name.d.value, enclosingScope.nodeType === 31 /* ParseNodeType.Function */ ? 1 /* TypeVarScopeType.Function */ : 0 /* TypeVarScopeType.Class */);
+        }
+        if ((flags & 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */) === 0) {
+            if (type.priv.scopeId && !scopedTypeVarInfo.foundInterveningClass) {
+                return type;
+            }
+            if (!type.shared.isSynthesized) {
+                const message = (0, types_1.isParamSpec)(type)
+                    ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
+                    : localize_1.LocMessage.typeVarNotUsedByOuterScope();
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.shared.name }), node);
+            }
+        }
+        return type;
+    }
+    // Enforce that the type variable is scoped to the enclosing class or
+    // an outer class that contains the class definition.
+    function enforceClassTypeVarScope(node, type) {
+        var _a, _b;
+        const scopeId = (_b = (_a = type.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : type.priv.scopeId;
+        if (!scopeId) {
+            return true;
+        }
+        const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
+        if (enclosingClass) {
+            const liveTypeVarScopeIds = ParseTreeUtils.getTypeVarScopesForNode(enclosingClass);
+            if (!liveTypeVarScopeIds.includes(scopeId)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarInvalidForMemberVariable().format({
+                    name: types_1.TypeVarType.getReadableName(type),
+                }), node);
+                return false;
+            }
+        }
+        return true;
+    }
     // Determines if the type is a generic class or type alias with missing
     // type arguments. If so, it fills in these type arguments with Unknown
     // and optionally reports an error.
@@ -3378,10 +3449,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
         while (curNode) {
-            curNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
-            if (!curNode) {
+            const scopeNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
+            if (!scopeNode) {
                 break;
             }
+            curNode = scopeNode;
             let typeParametersForScope;
             let scopeUsesTypeParameterSyntax = false;
             if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
@@ -3412,6 +3484,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type = types_1.TypeVarType.cloneForScopeId(type, match.priv.scopeId, match.priv.scopeName, match.priv.scopeType);
                     return {
                         type,
+                        scopeNode,
                         foundInterveningClass: nestedClassCount > 1 && !scopeUsesTypeParameterSyntax,
                     };
                 }
@@ -3422,15 +3495,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         curNode = node;
         while (curNode) {
             let leftType;
-            let typeAliasNode = undefined;
+            let typeAliasNode;
+            let scopeNode;
             if (curNode.nodeType === 77 /* ParseNodeType.TypeAlias */) {
                 leftType = readTypeCache(curNode.d.name, 0 /* EvalFlags.None */);
                 typeAliasNode = curNode;
+                scopeNode = curNode;
             }
             else if (curNode.nodeType === 3 /* ParseNodeType.Assignment */) {
                 leftType = readTypeCache(curNode.d.leftExpr, 0 /* EvalFlags.None */);
+                scopeNode = curNode;
             }
-            if (leftType) {
+            if (leftType && scopeNode) {
                 // Is this a placeholder that was temporarily written to the cache for
                 // purposes of resolving type aliases?
                 if (leftType && (0, types_1.isTypeVar)(leftType) && leftType.shared.recursiveAlias) {
@@ -3449,12 +3525,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (allowedTypeParams) {
                             if (!allowedTypeParams.some((param) => param.shared.name === type.shared.name)) {
                                 // Return the original type.
-                                return { type, foundInterveningClass: false };
+                                return { type, scopeNode, foundInterveningClass: false };
                             }
                         }
                     }
                     return {
                         type: types_1.TypeVarType.cloneForScopeId(type, leftType.shared.recursiveAlias.scopeId, leftType.shared.recursiveAlias.name, 2 /* TypeVarScopeType.TypeAlias */),
+                        scopeNode,
                         foundInterveningClass: false,
                     };
                 }
@@ -3462,7 +3539,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             curNode = curNode.parent;
         }
         // Return the original type.
-        return { type, foundInterveningClass: false };
+        return { type, scopeNode: undefined, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
         var _a, _b;
@@ -3599,7 +3676,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             const errorMessage = isArgs
                                 ? localize_1.LocMessage.paramSpecArgsUsage()
                                 : localize_1.LocMessage.paramSpecKwargsUsage();
-                            addError(errorMessage, node);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, errorMessage, node);
                             type = types_1.UnknownType.create(isIncomplete);
                             break;
                         }
@@ -3915,7 +3992,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
                     type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type;
                     if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
-                        type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType);
+                        type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType, 
+                        /* typeClassType */ undefined, selfType);
                     }
                     // If we're setting a class variable via a write through an object,
                     // this is normally considered a type violation. But it is allowed
@@ -4118,14 +4196,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         /* usage */ undefined, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
         if (!methodTypeResult || methodTypeResult.typeErrors) {
             // Provide special error messages for properties.
-            if (types_1.ClassType.isPropertyClass(concreteMemberType)) {
-                if (usage.method !== 'get') {
-                    const message = usage.method === 'set'
-                        ? localize_1.LocAddendum.propertyMissingSetter()
-                        : localize_1.LocAddendum.propertyMissingDeleter();
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(message.format({ name: memberName }));
-                    return { type: types_1.AnyType.create(), typeErrors: true };
-                }
+            if (types_1.ClassType.isPropertyClass(concreteMemberType) && usage.method !== 'get') {
+                const message = usage.method === 'set' ? localize_1.LocAddendum.propertyMissingSetter() : localize_1.LocAddendum.propertyMissingDeleter();
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(message.format({ name: memberName }));
+                return { type: types_1.AnyType.create(), typeErrors: true };
+            }
+            if (classType.shared.typeVarScopeId) {
+                memberType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(memberType, [classType.shared.typeVarScopeId]);
             }
             return { type: memberType };
         }
@@ -4177,7 +4254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 assignType(types_1.ClassType.cloneAsInstance(accessMethodClass), types_1.ClassType.cloneAsInstance(memberInfo.classType), 
                 /* diag */ undefined, typeVarContext);
                 accessMethodClass = (0, typeUtils_1.applySolvedTypeVars)(accessMethodClass, typeVarContext);
-                const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, accessMethodClass, selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
+                const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, accessMethodClass, getTypeClassType(), selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
                 if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloadedFunction)(specializedType)) {
                     methodType = specializedType;
                 }
@@ -4250,8 +4327,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return validateCallArguments(errorNode, argList, { type: methodType }, 
             /* typeVarContext */ undefined, 
             /* skipUnknownArgCheck */ true, 
-            /* inferenceContext */ undefined, 
-            /* signatureTracker */ undefined);
+            /* inferenceContext */ undefined);
         }, (suppressedDiags) => {
             // If diagnostics were recorded when suppressed, add them to the
             // diagnostic as messages.
@@ -4435,8 +4511,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMemberType));
         const callResult = validateCallArguments(errorNode, argList, { type: accessMemberType }, typeVarContext, 
         /* skipUnknownArgCheck */ true, 
-        /* inferenceContext */ undefined, 
-        /* signatureTracker */ undefined);
+        /* inferenceContext */ undefined);
         let isAsymmetricAccessor = false;
         if (usage.method === 'set') {
             isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
@@ -4454,7 +4529,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // runtime exception.
         if (flags & 128 /* EvalFlags.InstantiableType */) {
             if (node.d.leftExpr.nodeType === 48 /* ParseNodeType.StringList */) {
-                addError(localize_1.LocMessage.stringNotSubscriptable(), node.d.leftExpr);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.stringNotSubscriptable(), node.d.leftExpr);
             }
         }
         // Check for builtin classes that will generate runtime exceptions if subscripted.
@@ -4478,7 +4553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (minPythonVersion !== undefined &&
                         fileInfo.executionEnvironment.pythonVersion.isLessThan(minPythonVersion) &&
                         !fileInfo.isStubFile) {
-                        addError(localize_1.LocMessage.classNotRuntimeSubscriptable().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.classNotRuntimeSubscriptable().format({
                             name: baseTypeResult.type.priv.aliasName || baseTypeResult.type.shared.name,
                         }), node.d.leftExpr);
                     }
@@ -4634,7 +4709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // If the variadic type variable is not unpacked, report an error.
     function validateVariadicTypeVarIsUnpacked(type, node) {
         if (!type.priv.isVariadicUnpacked) {
-            addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                 name1: type.shared.name,
                 name2: type.shared.name,
             }), node);
@@ -4681,14 +4756,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             minTypeArgCount = firstDefaultParamIndex;
         }
         if (typeArgs.length > typeParameters.length) {
-            addError(localize_1.LocMessage.typeArgsTooMany().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
                 name: printType(baseType),
                 expected: typeParameters.length,
                 received: typeArgs.length,
             }), typeArgs[typeParameters.length].node);
         }
         else if (typeArgs.length < minTypeArgCount) {
-            addError(localize_1.LocMessage.typeArgsTooFew().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooFew().format({
                 name: printType(baseType),
                 expected: typeParameters.length,
                 received: typeArgs.length,
@@ -4747,12 +4822,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
                 }
                 else {
-                    addError(localize_1.LocMessage.typeArgListExpected(), typeArgs[index].node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListExpected(), typeArgs[index].node);
                 }
             }
             else {
                 if (index < typeArgs.length && typeArgs[index].typeList) {
-                    addError(localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[index].node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[index].node);
                 }
                 let typeArgType;
                 if (index < typeArgs.length) {
@@ -4791,7 +4866,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (!diag.isEmpty()) {
-            addError(localize_1.LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
         }
         const primarySignatureContext = typeVarContext.getPrimarySignature();
         const aliasTypeArgs = [];
@@ -4889,14 +4964,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const typeArgs = getTypeArgs(node, flags);
                     if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                         if ((flags & 32768 /* EvalFlags.VarTypeAnnotation */) === 0) {
-                            addError(localize_1.LocMessage.initVarNotAllowed(), node.d.leftExpr);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.initVarNotAllowed(), node.d.leftExpr);
                         }
                     }
                     if (typeArgs.length === 1) {
                         return typeArgs[0].type;
                     }
                     else {
-                        addError(localize_1.LocMessage.typeArgsMismatchOne().format({ received: typeArgs.length }), node.d.leftExpr);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsMismatchOne().format({ received: typeArgs.length }), node.d.leftExpr);
                         return types_1.UnknownType.create();
                     }
                 }
@@ -5225,8 +5300,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
         /* typeVarContext */ undefined, 
         /* skipUnknownArgCheck */ true, 
-        /* inferenceContext */ undefined, 
-        /* signatureTracker */ undefined);
+        /* inferenceContext */ undefined);
         return {
             type: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
@@ -5279,7 +5353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
-        let adjFlags = flags;
+        let adjFlags = flags | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if (options === null || options === void 0 ? void 0 : options.isFinalAnnotation) {
             adjFlags |= 131072 /* EvalFlags.NoClassVar */ | 16 /* EvalFlags.NoFinal */;
         }
@@ -5368,13 +5442,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
                             }
                             else {
-                                addError(localize_1.LocMessage.unpackNotAllowed(), arg.d.valueExpr);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackNotAllowed(), arg.d.valueExpr);
                             }
                         }
                     }
                 }
                 if (arg.d.name) {
-                    addError(localize_1.LocMessage.keywordArgInTypeArgument(), arg.d.valueExpr);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), arg.d.valueExpr);
                 }
                 if (arg.d.valueExpr.nodeType !== 0 /* ParseNodeType.Error */ ||
                     arg.d.valueExpr.d.category !== 3 /* ErrorExpressionCategory.MissingIndexOrSlice */) {
@@ -5405,18 +5479,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
             if (node.nodeType === 18 /* ParseNodeType.Dictionary */) {
-                addError(localize_1.LocMessage.dictInAnnotation(), node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.dictInAnnotation(), node);
             }
             if ((flags & 131072 /* EvalFlags.NoClassVar */) !== 0) {
                 // "ClassVar" is not allowed as a type argument.
                 if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ClassVar')) {
-                    addError(localize_1.LocMessage.classVarNotAllowed(), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarNotAllowed(), node);
                 }
             }
         }
         return typeResult;
     }
-    function getTypeOfTuple(node, flags, inferenceContext, signatureTracker) {
+    function getTypeOfTuple(node, flags, inferenceContext) {
         var _a;
         if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             // This is allowed inside of an index trailer, specifically
@@ -5443,8 +5517,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (!matchingSubtype) {
                     const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype), 
-                        /* signatureTracker */ undefined);
+                        return getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype));
                     });
                     if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                         matchingSubtype = subtype;
@@ -5456,7 +5529,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expectedTypeDiagAddendum;
         if (expectedType) {
-            const result = getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(expectedType), signatureTracker);
+            const result = getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -5470,7 +5543,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { ...typeResult, expectedTypeDiagAddendum };
     }
-    function getTypeOfTupleWithContext(node, flags, inferenceContext, signatureTracker) {
+    function getTypeOfTupleWithContext(node, flags, inferenceContext) {
         inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
         if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
             return undefined;
@@ -5508,7 +5581,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 expectedTypes.push(homogenousType);
             }
         }
-        const entryTypeResults = node.d.items.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete), signatureTracker));
+        const entryTypeResults = node.d.items.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete)));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         const type = makeTupleObject(buildTupleTypesList(entryTypeResults, /* stripLiterals */ false));
         // Copy any expected type diag addenda for precision error reporting.
@@ -5577,7 +5650,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return entryTypes;
     }
-    function getTypeOfCall(node, flags, inferenceContext, signatureTracker) {
+    function getTypeOfCall(node, flags, inferenceContext) {
         var _a;
         let baseTypeResult;
         // Check for the use of `type(x)` within a type annotation. This isn't
@@ -5607,12 +5680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return functionArg;
         });
         let typeResult = { type: types_1.UnknownType.create() };
-        // If the inference context has an associated signature tracker, make sure
-        // the base type of this call is not the same as one of the tracked signatures.
-        // This is important for nested generic calls (e.g. "foo(foo(x))").
-        if (signatureTracker) {
-            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, signatureTracker, node.start);
-        }
+        baseTypeResult.type = ensureSignatureIsUnique(baseTypeResult.type, node);
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && node.d.leftExpr.d.value === 'super') {
                 // Handle the built-in "super" call specially.
@@ -5622,15 +5690,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
                 node.d.leftExpr.d.value === 'reveal_type') {
                 // Handle the implicit "reveal_type" call.
-                typeResult = getTypeOfRevealType(node, inferenceContext, signatureTracker);
+                typeResult = getTypeOfRevealType(node, inferenceContext);
             }
             else if ((0, types_1.isFunction)(baseTypeResult.type) && types_1.FunctionType.isBuiltIn(baseTypeResult.type, 'reveal_type')) {
                 // Handle the "typing.reveal_type" call.
-                typeResult = getTypeOfRevealType(node, inferenceContext, signatureTracker);
+                typeResult = getTypeOfRevealType(node, inferenceContext);
             }
             else if ((0, types_1.isFunction)(baseTypeResult.type) && types_1.FunctionType.isBuiltIn(baseTypeResult.type, 'assert_type')) {
                 // Handle the "typing.assert_type" call.
-                typeResult = getTypeOfAssertType(node, inferenceContext, signatureTracker);
+                typeResult = getTypeOfAssertType(node, inferenceContext);
             }
             else if ((0, types_1.isAnyOrUnknown)(baseTypeResult.type) &&
                 node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
@@ -5640,13 +5708,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeResult.type = getTypeOfRevealLocals(node);
                 }
                 else {
-                    addError(localize_1.LocMessage.revealLocalsArgs(), node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.revealLocalsArgs(), node);
                 }
             }
             else {
                 const callResult = validateCallArguments(node, argList, baseTypeResult, 
                 /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, inferenceContext, signatureTracker);
+                /* skipUnknownArgCheck */ false, inferenceContext);
                 typeResult.type = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 if (callResult.argumentErrors) {
                     typeResult.typeErrors = true;
@@ -5735,17 +5803,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfAssertType(node, inferenceContext, signatureTracker) {
+    function getTypeOfAssertType(node, inferenceContext) {
         if (node.d.args.length !== 2 ||
             node.d.args[0].d.argCategory !== 0 /* ArgumentCategory.Simple */ ||
             node.d.args[0].d.name !== undefined ||
             node.d.args[0].d.argCategory !== 0 /* ArgumentCategory.Simple */ ||
             node.d.args[1].d.name !== undefined) {
-            addError(localize_1.LocMessage.assertTypeArgs(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.assertTypeArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
-        const arg0TypeResult = getTypeOfExpression(node.d.args[0].d.valueExpr, 
-        /* flags */ undefined, inferenceContext, signatureTracker);
+        const arg0TypeResult = getTypeOfExpression(node.d.args[0].d.valueExpr, /* flags */ undefined, inferenceContext);
         if (arg0TypeResult.isIncomplete) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
@@ -5759,7 +5826,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: arg0TypeResult.type };
     }
-    function getTypeOfRevealType(node, inferenceContext, signatureTracker) {
+    function getTypeOfRevealType(node, inferenceContext) {
         let arg0Value;
         let expectedRevealTypeNode;
         let expectedRevealType;
@@ -5781,7 +5848,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!(0, types_1.isClassInstance)(expectedTextType) ||
                     !types_1.ClassType.isBuiltIn(expectedTextType, 'str') ||
                     typeof expectedTextType.priv.literalValue !== 'string') {
-                    addError(localize_1.LocMessage.revealTypeExpectedTextArg(), arg.d.valueExpr);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.revealTypeExpectedTextArg(), arg.d.valueExpr);
                 }
                 else {
                     expectedText = expectedTextType.priv.literalValue;
@@ -5793,17 +5860,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (!arg0Value) {
-            addError(localize_1.LocMessage.revealTypeArgs(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.revealTypeArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
-        const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, inferenceContext, signatureTracker);
+        const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, inferenceContext);
         const type = typeResult.type;
         const exprString = ParseTreeUtils.printExpression(arg0Value);
         const typeString = printType(type, { expandTypeAlias: true });
         if (!typeResult.isIncomplete) {
             if (expectedText !== undefined) {
                 if (expectedText !== typeString) {
-                    addError(localize_1.LocMessage.revealTypeExpectedTextMismatch().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.revealTypeExpectedTextMismatch().format({
                         expected: expectedText,
                         received: typeString,
                     }), expectedTextNode !== null && expectedTextNode !== void 0 ? expectedTextNode : arg0Value);
@@ -5812,7 +5879,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (expectedRevealType) {
                 if (!(0, types_1.isTypeSame)(expectedRevealType, type, { ignorePseudoGeneric: true })) {
                     const expectedRevealTypeText = printType(expectedRevealType);
-                    addError(localize_1.LocMessage.revealTypeExpectedTypeMismatch().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.revealTypeExpectedTypeMismatch().format({
                         expected: expectedRevealTypeText,
                         received: typeString,
                     }), expectedRevealTypeNode !== null && expectedRevealTypeNode !== void 0 ? expectedRevealTypeNode : arg0Value);
@@ -5857,7 +5924,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfSuperCall(node) {
         var _a, _b;
         if (node.d.args.length > 2) {
-            addError(localize_1.LocMessage.superCallArgCount(), node.d.args[2]);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.superCallArgCount(), node.d.args[2]);
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node);
         const enclosingClass = enclosingFunction ? ParseTreeUtils.getEnclosingClass(enclosingFunction) : undefined;
@@ -5883,12 +5950,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
                     /* isInClass */ true);
                     if (((functionInfo === null || functionInfo === void 0 ? void 0 : functionInfo.flags) & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
-                        addError(localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.d.leftExpr);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.d.leftExpr);
                     }
                 }
             }
             else {
-                addError(localize_1.LocMessage.superCallZeroArgForm(), node.d.leftExpr);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgForm(), node.d.leftExpr);
                 targetClassType = types_1.UnknownType.create();
             }
         }
@@ -5942,7 +6009,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         types_1.FunctionType.isInstanceMethod(methodType)) {
                         if (methodType.shared.parameters.length > 0 &&
                             types_1.FunctionParam.isTypeDeclared(methodType.shared.parameters[0])) {
-                            implicitBindToType = makeTopLevelTypeVarsConcrete(methodType.shared.parameters[0].type);
+                            let paramType = methodType.shared.parameters[0].type;
+                            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                            paramType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(paramType, liveScopeIds);
+                            implicitBindToType = makeTopLevelTypeVarsConcrete(paramType);
                         }
                     }
                 }
@@ -5991,6 +6061,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isProtocolClass = true;
                 effectiveTargetClass = undefined;
             }
+            if (bindToType) {
+                bindToType = (0, typeUtils_1.selfSpecializeClass)(bindToType, { useInternalTypeVars: true });
+            }
             const lookupResults = bindToType
                 ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* MemberAccessFlags.Default */, effectiveTargetClass)
                 : undefined;
@@ -6011,13 +6084,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 resultType = types_1.UnknownType.create();
             }
-            return {
-                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType,
-                bindToSelfType: bindToType
-                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
-                    /* isClsParam */ false), (_b = bindToType.props) === null || _b === void 0 ? void 0 : _b.condition)
-                    : undefined,
-            };
+            let bindToSelfType;
+            if (bindToType) {
+                bindToSelfType = types_1.TypeBase.cloneForCondition(types_1.TypeVarType.cloneWithInternalScopeId((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
+                /* isClsParam */ false)), (_b = bindToType.props) === null || _b === void 0 ? void 0 : _b.condition);
+            }
+            const type = resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType;
+            return { type, bindToSelfType };
         }
         // Handle the super() call when used outside of a member access expression.
         if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
@@ -6073,6 +6146,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: types_1.UnknownType.create() };
     }
+    // When evaluating a call, the errorNode is typically the call node, which
+    // encompasses all of the argument expressions. This means we can normally
+    // use the errorNode as the root for speculative evaluation. However, there
+    // are some cases where we don't have a call node (e.g. in the case of an
+    // __init_subclass__ validation). Here we need to find some other parent
+    // node of the error node that encompasses all of the arguments.
+    function getSpeculativeNodeForCall(errorNode) {
+        var _a;
+        // If the error node is within an arg, expand to include the parent of the arg list.
+        const argParent = ParseTreeUtils.getParentNodeOfType(errorNode, 1 /* ParseNodeType.Argument */);
+        if (argParent === null || argParent === void 0 ? void 0 : argParent.parent) {
+            return argParent.parent;
+        }
+        // If the error node is the name in a class declaration, expand to include the class node.
+        if (errorNode.nodeType === 38 /* ParseNodeType.Name */ &&
+            ((_a = errorNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 10 /* ParseNodeType.Class */ &&
+            errorNode.parent.d.name === errorNode) {
+            return errorNode.parent;
+        }
+        return errorNode;
+    }
     // Attempts to find an overloaded function for each set of argument
     // types in the expandedArgTypes list. If an argument type is undefined,
     // its type is evaluated from the argument's expression using the
@@ -6080,13 +6174,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // there will be only one argument list in expandedArgTypes, and all entries
     // (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, inferenceContext, signatureTracker) {
+    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
         let overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
+        const speculativeNode = getSpeculativeNodeForCall(errorNode);
         for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
             let matchedOverload;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
@@ -6114,9 +6209,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 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, () => {
+                const callResult = useSpeculativeMode(speculativeNode, () => {
                     return validateArgTypesWithContext(errorNode, matchResults, effectiveTypeVarContext, 
-                    /* skipUnknownArgCheck */ true, inferenceContext, signatureTracker);
+                    /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 if (callResult.isTypeIncomplete) {
                     isTypeIncomplete = true;
@@ -6225,7 +6320,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
         finalTypeVarContext.unlock();
         finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
-        const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+        const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -6287,24 +6382,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getBestOverloadForArguments(errorNode, typeResult, argList) {
         let overloadIndex = 0;
         let matches = [];
-        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-        // Create a list of potential overload matches based on arguments.
-        types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
-            useSpeculativeMode(errorNode, () => {
-                const matchResults = matchArgsToParams(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex, 
-                /* signatureTracker */ undefined);
-                if (!matchResults.argumentErrors) {
-                    matches.push(matchResults);
-                }
-                overloadIndex++;
+        const speculativeNode = getSpeculativeNodeForCall(errorNode);
+        useSignatureTracker(errorNode, () => {
+            // Create a list of potential overload matches based on arguments.
+            types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
+                useSpeculativeMode(speculativeNode, () => {
+                    const matchResults = matchArgsToParams(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
+                    if (!matchResults.argumentErrors) {
+                        matches.push(matchResults);
+                    }
+                    overloadIndex++;
+                });
             });
         });
         matches = sortOverloadsByBestMatch(matches);
         let winningOverloadIndex;
         matches.forEach((match, matchIndex) => {
             if (winningOverloadIndex === undefined) {
-                useSpeculativeMode(errorNode, () => {
-                    const callResult = validateArgTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), signatureTracker, 
+                useSpeculativeMode(speculativeNode, () => {
+                    const callResult = validateArgTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), 
                     /* skipUnknownArgCheck */ true);
                     if (callResult && !callResult.argumentErrors) {
                         winningOverloadIndex = matchIndex;
@@ -6323,22 +6419,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return a.overloadIndex - b.overloadIndex;
         });
     }
-    function validateOverloadedFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
+    function validateOverloadedArgTypes(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
+        const type = typeResult.type;
+        const speculativeNode = getSpeculativeNodeForCall(errorNode);
         // Start by evaluating the types of the arguments without any expected
         // type. Also, filter the list of overloads based on the number of
         // positional and named arguments that are present. We do all of this
         // speculatively because we don't want to record any types in the type
         // cache or record any diagnostics at this stage.
-        useSpeculativeMode(errorNode, () => {
+        useSpeculativeMode(speculativeNode, () => {
             let overloadIndex = 0;
-            types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
+            types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
-                const matchResults = matchArgsToParams(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex, signatureTracker);
+                const matchResults = matchArgsToParams(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
                 if (!matchResults.argumentErrors) {
                     filteredMatchResults.push(matchResults);
                 }
@@ -6352,10 +6450,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Skip the error message if we're in speculative mode because it's very
             // expensive, and we're going to suppress the diagnostic anyway.
             if (!canSkipDiagnosticForNode(errorNode)) {
-                const functionName = typeResult.type.priv.overloads[0].shared.name || '<anonymous function>';
+                const functionName = type.priv.overloads[0].shared.name || '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const argTypes = argList.map((t) => {
-                    const typeString = printType(getTypeOfArgument(t, /* inferenceContext */ undefined, signatureTracker).type);
+                    const typeString = printType(getTypeOfArgument(t, /* inferenceContext */ undefined).type);
                     if (t.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
                         return `*${typeString}`;
                     }
@@ -6394,7 +6492,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(bestMatch.overload));
             effectiveTypeVarContext.unlock();
-            return validateArgTypesWithContext(errorNode, bestMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+            return validateArgTypesWithContext(errorNode, bestMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         }
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
@@ -6406,7 +6504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
         while (true) {
-            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
             if (callResult.isTypeIncomplete) {
                 isTypeIncomplete = true;
             }
@@ -6416,7 +6514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // We didn't find an overload match. Try to expand the next union
             // argument type into individual types and retry with the expanded types.
             if (!contextFreeArgTypes) {
-                useSpeculativeMode(errorNode, () => {
+                useSpeculativeMode(getSpeculativeNodeForCall(errorNode), () => {
                     // Evaluate the types of each argument expression without regard to
                     // the context. We'll use this to determine whether we need to do
                     // union expansion.
@@ -6504,7 +6602,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
     // the way, it emits a diagnostic and sets argumentErrors to true.
-    function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount = 0) {
+    function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount = 0) {
         var _a;
         let argumentErrors = false;
         let isTypeIncomplete = false;
@@ -6523,8 +6621,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
         let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, { sortSubtypes: true }, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
-            return useSpeculativeMode(isLastIteration ? undefined : errorNode, () => {
-                const callResult = validateCallArgumentsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
+            return useSpeculativeMode(isLastIteration ? undefined : getSpeculativeNodeForCall(errorNode), () => {
+                const callResult = validateCallArgumentsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
                 if (callResult.argumentErrors) {
                     argumentErrors = true;
                 }
@@ -6554,7 +6652,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             overloadsUsedForCall,
         };
     }
-    function validateCallArgumentsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount) {
+    function validateCallArgumentsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
         switch (expandedCallType.category) {
             case 3 /* TypeCategory.Never */:
             case 1 /* TypeCategory.Unknown */:
@@ -6565,17 +6663,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!isCallTypeIncomplete) {
                     argList.forEach((arg) => {
                         if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
-                            getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker);
+                            getTypeOfArgument(arg, /* inferenceContext */ undefined);
                         }
                     });
                 }
                 return { returnType: expandedCallType };
             }
             case 4 /* TypeCategory.Function */: {
-                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
             }
             case 5 /* TypeCategory.OverloadedFunction */: {
-                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
             }
             case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
@@ -6583,16 +6681,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { argumentErrors: true };
                 }
                 if (types_1.TypeBase.isInstantiable(expandedCallType)) {
-                    return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker);
+                    return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext);
                 }
-                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
+                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
             // TypeVars should have been expanded in most cases,
             // but we still need to handle the case of Type[T] where
             // T is a constrained type that contains a union. We also
             // need to handle recursive type aliases.
             case 9 /* TypeCategory.TypeVar */: {
-                return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
+                return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
             case 7 /* TypeCategory.Module */: {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
@@ -6601,7 +6699,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { argumentErrors: true };
     }
-    function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
+    function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a;
         if (types_1.TypeBase.isInstantiable(type)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.callableNotInstantiable().format({
@@ -6609,11 +6707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
         }
-        let effectiveTypeVarContext = typeVarContext;
-        if (!effectiveTypeVarContext) {
-            // If a typeVarContext wasn't provided by the caller, allocate one here.
-            effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(type));
-        }
+        const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(type));
         // The stdlib collections/__init__.pyi stub file defines namedtuple
         // as a function rather than a class, so we need to check for it here.
         if (types_1.FunctionType.isBuiltIn(type, 'namedtuple')) {
@@ -6621,14 +6715,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const result = {
                 returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
             };
-            validateArgs(errorNode, argList, { type: type }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+            validateArgs(errorNode, argList, { type: type }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
             return result;
         }
         // Handle the NewType specially, replacing the normal return type.
         if (types_1.FunctionType.isBuiltIn(type, 'NewType')) {
             return { returnType: createNewType(errorNode, argList) };
         }
-        const functionResult = validateArgs(errorNode, argList, { type, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+        const functionResult = validateArgs(errorNode, argList, { type, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         let isTypeIncomplete = !!functionResult.isTypeIncomplete;
         let returnType = functionResult.returnType;
         let argumentErrors = !!functionResult.argumentErrors;
@@ -6735,13 +6829,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { symbol, symbolName, classType, hasImplementation };
     }
-    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker) {
+    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         // Handle the 'cast' call as a special case.
         if (types_1.FunctionType.isBuiltIn(expandedCallType.priv.overloads[0], 'cast') && argList.length === 2) {
             return { returnType: evaluateCastCall(argList, errorNode) };
         }
-        const callResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+        const callResult = validateOverloadedArgTypes(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
         let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         let isTypeIncomplete = !!callResult.isTypeIncomplete;
         let argumentErrors = !!callResult.argumentErrors;
@@ -6768,7 +6862,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             specializedInitSelfType: callResult.specializedInitSelfType,
         };
     }
-    function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker) {
+    function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         if (expandedCallType.priv.literalValue !== undefined) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.literalNotCallable(), errorNode);
@@ -6785,12 +6879,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { returnType: types_1.UnknownType.create(), argumentErrors: true };
                 }
                 // Validate the constructor arguments.
-                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker);
+                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
                 // The one-parameter form of "type" returns the class
                 // for the specified object.
                 if (expandedCallType.shared.name === 'type' && argList.length === 1) {
-                    const argType = getTypeOfArgument(argList[0], 
-                    /* inferenceContext */ undefined, signatureTracker).type;
+                    const argType = getTypeOfArgument(argList[0], /* inferenceContext */ undefined).type;
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
                         if ((0, types_1.isInstantiableClass)(subtype) && subtype.shared.effectiveMetaclass) {
                             return subtype.shared.effectiveMetaclass;
@@ -6850,9 +6943,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
                 /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
-                    validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
+                    validateOverloadedArgTypes(errorNode, argList, { type: initTypeResult.type }, 
                     /* typeVarContext */ undefined, skipUnknownArgCheck, 
-                    /* inferenceContext */ undefined, signatureTracker);
+                    /* inferenceContext */ undefined);
                 }
                 return result;
             }
@@ -6916,7 +7009,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }), errorNode);
         }
         // Assume this is a call to the constructor.
-        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext, signatureTracker);
+        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
         const overloadsUsedForCall = constructorResult.overloadsUsedForCall;
         const argumentErrors = constructorResult.argumentErrors;
         const isTypeIncomplete = constructorResult.isTypeIncomplete;
@@ -6943,8 +7036,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             returnType.shared.mro.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'type'))) {
             let newClassName = '__class_' + returnType.shared.name;
             if (argList.length === 3) {
-                const firstArgType = getTypeOfArgument(argList[0], 
-                /* inferenceContext */ undefined, signatureTracker).type;
+                const firstArgType = getTypeOfArgument(argList[0], /* inferenceContext */ undefined).type;
                 if ((0, types_1.isClassInstance)(firstArgType) &&
                     types_1.ClassType.isBuiltIn(firstArgType, 'str') &&
                     typeof firstArgType.priv.literalValue === 'string') {
@@ -6960,7 +7052,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
     }
-    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount) {
+    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
         var _a;
         const callDiag = new diagnostic_1.DiagnosticAddendum();
         const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
@@ -6973,7 +7065,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }) + callDiag.getString(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
-        const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker, recursionCount);
+        const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
         let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         if ((0, types_1.isTypeVar)(unexpandedCallType) &&
             types_1.TypeBase.isInstantiable(unexpandedCallType) &&
@@ -6994,9 +7086,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a;
         // Verify that the cast is necessary.
         const castToType = getTypeOfArgumentExpectingType(argList[0], { enforceTypeAnnotationRules: true }).type;
-        let castFromType = getTypeOfArgument(argList[1], 
-        /* inferenceContext */ undefined, 
-        /* signatureTracker */ undefined).type;
+        let castFromType = getTypeOfArgument(argList[1], /* inferenceContext */ undefined).type;
         if ((_a = castFromType.props) === null || _a === void 0 ? void 0 : _a.specialForm) {
             castFromType = castFromType.props.specialForm;
         }
@@ -7012,12 +7102,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return (0, typeUtils_1.convertToInstance)(castToType);
     }
     // Expands any unpacked tuples within an argument list.
-    function expandArgList(argList, signatureTracker) {
+    function expandArgList(argList) {
         var _a;
         const expandedArgList = [];
         for (const arg of argList) {
             if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
-                const argType = getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker).type;
+                const argType = getTypeOfArgument(arg, /* inferenceContext */ undefined).type;
                 // If this is a tuple with specified element types, use those
                 // specified types rather than using the more generic iterator
                 // type which will be a union of all element types.
@@ -7059,7 +7149,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // function. This matching is done based on positions and keywords. Type evaluation and
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
-    function matchArgsToParams(errorNode, argList, typeResult, overloadIndex, signatureTracker) {
+    function matchArgsToParams(errorNode, argList, typeResult, overloadIndex) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const overload = typeResult.type;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(overload);
@@ -7070,7 +7160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let isTypeIncomplete = !!typeResult.isIncomplete;
         let isVariadicTypeVarFullyMatched = false;
         // Expand any unpacked tuples in the arg list.
-        argList = expandArgList(argList, signatureTracker);
+        argList = expandArgList(argList);
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
@@ -7194,8 +7284,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // If this is an unpacked iterable, we will conservatively assume that it
                         // might have zero iterations unless we can tell from its type that it
                         // definitely has at least one iterable value.
-                        const argType = getTypeOfArgument(argList[argIndex], 
-                        /* inferenceContext */ undefined, signatureTracker).type;
+                        const argType = getTypeOfArgument(argList[argIndex], /* inferenceContext */ undefined).type;
                         if ((0, types_1.isClassInstance)(argType) &&
                             (0, typeUtils_1.isTupleClass)(argType) &&
                             !(0, typeUtils_1.isUnboundedTupleClass)(argType) &&
@@ -7224,14 +7313,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             (0, debug_1.assert)(paramDetails.params[paramIndex], 'paramIndex params entry is undefined');
-            const paramType = paramDetails.params[paramIndex].type;
-            const paramName = paramDetails.params[paramIndex].param.name;
-            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* ParameterCategory.ArgsList */ &&
-                (0, types_1.isVariadicTypeVar)(paramType);
+            const paramInfo = paramDetails.params[paramIndex];
+            const paramType = paramInfo.type;
+            const paramName = paramInfo.param.name;
+            const isParamVariadic = paramInfo.param.category === 1 /* ParameterCategory.ArgsList */ && (0, types_1.isVariadicTypeVar)(paramType);
             if (argList[argIndex].argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
-                const argTypeResult = getTypeOfArgument(argList[argIndex], 
-                /* inferenceContext */ undefined, signatureTracker);
+                const argTypeResult = getTypeOfArgument(argList[argIndex], /* inferenceContext */ undefined);
                 let listElementType;
                 let advanceToNextArg = false;
                 // Handle the case where *args is being passed to a function defined
@@ -7241,7 +7329,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (paramIndex < positionParamLimitIndex) {
                     if ((0, types_1.isTypeVar)(argTypeResult.type) &&
                         argTypeResult.type.priv.paramSpecAccess === 'args' &&
-                        paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
+                        paramInfo.param.category !== 1 /* ParameterCategory.ArgsList */) {
                         if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
@@ -7292,7 +7380,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     listElementType = (_f = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
                     /* emitNotIterableError */ false)) === null || _f === void 0 ? void 0 : _f.type;
-                    if (paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
+                    if (paramInfo.param.category !== 1 /* ParameterCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
                 }
@@ -7314,18 +7402,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     reportedArgError = true;
                 }
                 else {
-                    if (paramSpecArgList) {
+                    if (paramSpecArgList && paramInfo.param.category !== 0 /* ParameterCategory.Simple */) {
                         paramSpecArgList.push(argList[argIndex]);
                     }
                     if (funcArg) {
                         validateArgTypeParams.push({
-                            paramCategory: paramDetails.params[paramIndex].param.category,
+                            paramCategory: paramInfo.param.category,
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
                             errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                             paramName,
-                            isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramDetails.params[paramIndex].param),
+                            isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramInfo.param),
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
                         });
                     }
@@ -7466,7 +7554,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
                     // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
-                    const argTypeResult = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType), signatureTracker);
+                    const argTypeResult = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType));
                     const argType = argTypeResult.type;
                     if (argTypeResult.isIncomplete) {
                         isTypeIncomplete = true;
@@ -7693,7 +7781,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // argument to a function that accepts a ParamSpec.
                         if (paramSpec) {
                             const argTypeResult = getTypeOfArgument(argList[argIndex], 
-                            /* inferenceContext */ undefined, signatureTracker);
+                            /* inferenceContext */ undefined);
                             const argType = argTypeResult.type;
                             if (argTypeResult.isIncomplete) {
                                 isTypeIncomplete = true;
@@ -7816,8 +7904,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((0, types_1.isVariadicTypeVar)(paramType) && !paramType.priv.isVariadicInUnion) {
                     const tupleTypeArgs = variadicArgs.map((argParam) => {
                         var _a;
-                        const argType = getTypeOfArgument(argParam.argument, 
-                        /* inferenceContext */ undefined, signatureTracker).type;
+                        const argType = getTypeOfArgument(argParam.argument, /* inferenceContext */ undefined).type;
                         const containsVariadicTypeVar = (0, types_1.isUnpackedVariadicTypeVar)(argType) ||
                             ((0, types_1.isClassInstance)(argType) &&
                                 (0, typeUtils_1.isTupleClass)(argType) &&
@@ -7896,114 +7983,111 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // After having matched arguments with parameters, this function evaluates the
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
-    function validateArgTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext, signatureTracker) {
+    function validateArgTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+        var _a;
         const type = matchResults.overload;
-        if (!signatureTracker) {
-            signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-        }
-        matchResults.overload = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(matchResults.overload, signatureTracker, errorNode.start);
-        const returnType = getFunctionEffectiveReturnType(type);
         let expectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
+        // Can we safely ignore the inference context, either because it's not provided
+        // or will have no effect? If so, avoid the extra work.
+        const returnType = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride) !== null && _a !== void 0 ? _a : getFunctionEffectiveReturnType(type);
+        if (!returnType || !(0, typeUtils_1.requiresSpecialization)(returnType)) {
+            expectedType = undefined;
+        }
+        const tryExpectedType = (expectedSubtype) => {
+            const clonedTypeVarContext = typeVarContext.clone();
+            const callResult = validateArgTypesWithExpectedType(errorNode, matchResults, clonedTypeVarContext, 
+            /* skipUnknownArgCheck */ true, expectedSubtype, returnType);
+            // Use a heuristic to pick a subtype that is most likely to be correct.
+            // We'll look for a subtype that produces no argument errors and has
+            // no Unknowns in the return type.
+            if (!callResult.argumentErrors && callResult.returnType) {
+                const returnType = (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride)
+                    ? (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.returnTypeOverride, clonedTypeVarContext)
+                    : callResult.returnType;
+                if (assignType(expectedSubtype, returnType, 
+                /* diag */ undefined, 
+                /* destTypeVarContext */ undefined, 
+                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(callResult.returnType, /* recurse */ true);
+                    // Prefer return types that have no unknown or Any.
+                    if (!anyOrUnknown) {
+                        return 3;
+                    }
+                    // Prefer Any over Unknown.
+                    return (0, types_1.isAny)(anyOrUnknown) ? 2 : 1;
+                }
+            }
+            return 0;
+        };
         // If the expected type is a union, we don't know which type is expected.
         // We may or may not be able to make use of the expected type. We'll evaluate
-        // speculatively to see if using the expected type works.
+        // speculatively to see if using one of the expected subtypes works.
         if (expectedType && (0, types_1.isUnion)(expectedType)) {
-            let assignFlags = 2048 /* AssignTypeFlags.PopulatingExpectedType */;
-            if ((0, typeUtils_1.containsLiteralType)(expectedType, /* includeTypeArgs */ true)) {
-                assignFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
-            }
-            useSpeculativeMode(errorNode, () => {
-                const typeVarContextCopy = typeVarContext.clone();
-                assignType(returnType, expectedType, 
-                /* diag */ undefined, typeVarContextCopy, 
-                /* srcTypeVarContext */ undefined, assignFlags);
-                const speculativeResults = validateArgTypes(errorNode, matchResults, typeVarContextCopy, signatureTracker, skipUnknownArgCheck);
-                if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
-                    expectedType = undefined;
+            expectedType = useSpeculativeMode(getSpeculativeNodeForCall(errorNode), () => {
+                let validExpectedSubtype;
+                let bestSubtypeScore = -1;
+                (0, typeUtils_1.doForEachSubtype)(expectedType, (expectedSubtype) => {
+                    if (bestSubtypeScore < 3) {
+                        const score = tryExpectedType(expectedSubtype);
+                        if (score > bestSubtypeScore) {
+                            validExpectedSubtype = expectedSubtype;
+                            bestSubtypeScore = score;
+                        }
+                    }
+                }, 
+                /* sortSubtypes */ true);
+                if (bestSubtypeScore < 3) {
+                    const score = tryExpectedType(expectedType);
+                    if (score > bestSubtypeScore) {
+                        validExpectedSubtype = expectedType;
+                    }
                 }
+                return validExpectedSubtype;
             });
         }
-        if (expectedType) {
-            if ((0, types_1.isAnyOrUnknown)(expectedType) || (0, types_1.isNever)(expectedType)) {
-                expectedType = undefined;
-            }
-        }
-        // Can we safely ignore the inference context, either because it's not provided
-        // or will have no effect? If so, we can eliminate some extra work.
-        if (!expectedType || !returnType || !(0, typeUtils_1.requiresSpecialization)(returnType)) {
-            return validateArgTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
+        // If there is no expected type, or the expected type is Any or Unknown,
+        // there's nothing left to do here.
+        if (!expectedType || (0, types_1.isAnyOrUnknown)(expectedType) || (0, types_1.isNever)(expectedType)) {
+            return validateArgTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
         }
-        return validateArgTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, expectedType, returnType, signatureTracker);
+        return validateArgTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, expectedType, returnType);
     }
-    function validateArgTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, expectedType, returnType, signatureTracker) {
+    function validateArgTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, expectedType, returnType) {
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         let assignFlags = 2048 /* AssignTypeFlags.PopulatingExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(expectedType, /* includeTypeArgs */ true)) {
             assignFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
         }
-        // Prepopulate the typeVarContext based on the specialized expected type if the
-        // callee has a declared return type. This will allow us to more closely match
-        // the expected type if possible.
-        // Determine which type arguments are needed to match the expected type.
-        if ((0, types_1.isClassInstance)(returnType)) {
-            // If the return type is a class and the expected type is a union
-            // that is type compatible with that class, filter the subtypes in
-            // the union to see if we can find one that is potentially compatible.
-            if ((0, types_1.isUnion)(expectedType)) {
-                const filteredType = (0, typeUtils_1.mapSubtypes)(expectedType, (subtype) => {
-                    if (!(0, types_1.isClassInstance)(subtype) || subtype.shared.typeParameters.length === 0) {
-                        return undefined;
-                    }
-                    if (types_1.ClassType.isProtocolClass(subtype) ||
-                        subtype.shared.mro.some((mroClass) => {
-                            return ((0, types_1.isClassInstance)(mroClass) &&
-                                mroClass.shared.typeParameters.length > 0 &&
-                                types_1.ClassType.isSameGenericClass(returnType, mroClass));
-                        })) {
-                        return subtype;
-                    }
-                    return undefined;
-                }, { sortSubtypes: true });
-                if ((0, types_1.isClassInstance)(filteredType)) {
-                    expectedType = filteredType;
-                }
-            }
-            if ((0, types_1.isClassInstance)(expectedType) && !(0, types_1.isTypeSame)(returnType, expectedType)) {
-                const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(returnType));
-                if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, returnType, expectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
-                    const genericReturnType = types_1.ClassType.cloneForSpecialization(returnType, 
-                    /* typeArguments */ undefined, 
-                    /* isTypeArgumentExplicit */ false);
-                    expectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
-                        unknownIfNotFound: true,
-                        tupleClassType: getTupleClassType(),
-                    });
-                    assignFlags |= 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
-                }
-            }
-        }
-        else if ((0, types_1.isFunction)(returnType)) {
-            // If the return type is a callable and the expected type is a union that
-            // includes one or more non-callables, filter those out.
-            if ((0, types_1.isUnion)(expectedType)) {
-                expectedType = (0, typeUtils_1.mapSubtypes)(expectedType, (subtype) => {
-                    return (0, typeUtils_1.isCallableType)(subtype) ? subtype : undefined;
+        // Prepopulate the typeVarContext based on the specialized expected type.
+        // This will allow us to more closely match the expected type if possible.
+        if ((0, types_1.isClassInstance)(returnType) && (0, types_1.isClassInstance)(expectedType) && !(0, types_1.isTypeSame)(returnType, expectedType)) {
+            const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(returnType));
+            if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, returnType, expectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
+                const genericReturnType = (0, typeUtils_1.selfSpecializeClass)(returnType, {
+                    overrideTypeArgs: true,
+                });
+                expectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
+                    unknownIfNotFound: true,
+                    useUnknownOverDefault: true,
+                    tupleClassType: getTupleClassType(),
                 });
+                assignFlags |= 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
             }
         }
         expectedType = (0, typeUtils_1.transformExpectedType)(expectedType, liveTypeVarScopes, errorNode.start);
         assignType(returnType, expectedType, 
         /* diag */ undefined, typeVarContext, 
         /* srcTypeVarContext */ undefined, assignFlags);
-        return validateArgTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
+        return validateArgTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
     }
-    function validateArgTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck) {
+    function validateArgTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck) {
         const type = matchResults.overload;
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let argumentMatchScore = 0;
         let specializedInitSelfType;
         let anyOrUnknownArgument;
+        const speculativeNode = getSpeculativeNodeForCall(errorNode);
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
         // Check for an attempt to invoke an unimplemented abstract method.
@@ -8056,7 +8140,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // where more than two passes are needed.
             let passCount = Math.min(typeVarMatchingCount, 2);
             for (let i = 0; i < passCount; i++) {
-                useSpeculativeMode(errorNode, () => {
+                useSpeculativeMode(speculativeNode, () => {
                     matchResults.argParams.forEach((argParam) => {
                         if (!argParam.requiresTypeVarMatching) {
                             return;
@@ -8073,7 +8157,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // expected type during the first pass. This causes problems for
                         // cases where the the call expression result can influence the
                         // type of the TypeVar, such as in the expression "min(1, max(2, 0.5))".
-                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+                        const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, {
                             skipUnknownArgCheck,
                             skipOverloadArg: i === 0,
                             skipBareTypeVarExpectedType: i === 0,
@@ -8101,7 +8185,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const argResults = [];
         matchResults.argParams.forEach((argParam, argParamIndex) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, {
                 skipUnknownArgCheck,
                 conditionFilter: typeCondition,
             });
@@ -8140,7 +8224,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let paramSpecTypeVarContext = [];
         // Handle the assignment of additional arguments that map to a param spec.
         if (matchResults.paramSpecArgList && matchResults.paramSpecTarget) {
-            const paramSpecArgResult = validateArgTypesForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext, signatureTracker);
+            const paramSpecArgResult = validateArgTypesForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext);
             if (paramSpecArgResult.argumentErrors) {
                 argumentErrors = true;
                 argumentMatchScore += 1;
@@ -8190,7 +8274,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // call to a generic function or if this isn't a callable
         // return with type parameters that are rescoped from the original
         // function to the returned callable.
-        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        const unknownIfNotFound = !liveTypeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope) ||
+            typeVarContext.hasSolveForScope(types_1.TypeVarType.makeInternalScopeId(typeVarScope)));
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             tupleClassType: getTupleClassType(),
@@ -8240,8 +8326,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClass, typeGuardType, useTypeIsSemantics));
             }
         }
-        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes, signatureTracker.getTrackedSignatures());
+        specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes);
         if (specializedInitSelfType) {
             specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
         }
@@ -8288,12 +8373,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // to allow these type vars to be solved. This won't work with overloads
     // or unions of callables. It's intended for a specific use case. We may
     // need to make this more sophisticated in the future.
-    // The trackedSignatures parameter supplies a list of function signatures
-    // that were used for the function and the arguments passed to it. This is
-    // important because the callable return value may be called again with
-    // one of these signatures, so we may need to "uniquify" the type parameters
-    // to avoid conflicts.
-    function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes, trackedSignatures) {
+    function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes) {
         if ((0, types_1.isFunction)(returnType) && !returnType.shared.name && callableType.shared.typeVarScopeId) {
             // What type variables are referenced in the callable return type? Do not include any live type variables.
             const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
@@ -8301,7 +8381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // unsolved type variables, treat them as though they are rescoped
             // to the callable.
             if (typeVarsInReturnType.length > 0) {
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, callableType.shared.typeVarScopeId, callableType.priv.constructorTypeVarScopeId, typeVarsInReturnType, trackedSignatures);
+                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, callableType.shared.typeVarScopeId, callableType.priv.constructorTypeVarScopeId, typeVarsInReturnType);
             }
         }
         return returnType;
@@ -8309,12 +8389,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
     // specialized return type of the call.
-    function validateArgs(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext, signatureTracker) {
-        if (!signatureTracker) {
-            signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-        }
-        typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, errorNode.start);
-        const matchResults = matchArgsToParams(errorNode, argList, typeResult, 0, signatureTracker);
+    function validateArgs(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+        const matchResults = matchArgsToParams(errorNode, argList, typeResult, 0);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
             // not reported as unaccessed.
@@ -8329,22 +8405,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 overloadsUsedForCall: [],
             };
         }
-        return validateArgTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete), signatureTracker);
+        return validateArgTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride));
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
-    function validateArgTypesForParamSpec(errorNode, argList, paramSpec, destTypeVarContext, signatureTracker) {
+    function validateArgTypesForParamSpec(errorNode, argList, paramSpec, destTypeVarContext) {
         const signatureContexts = destTypeVarContext.getSignatureContexts();
         // Handle the common case where there is only one signature context.
         if (signatureContexts.length === 1) {
-            return validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, signatureContexts[0], signatureTracker);
+            return validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, signatureContexts[0]);
         }
         const filteredSignatureContexts = [];
         const typeVarContexts = [];
+        const speculativeNode = getSpeculativeNodeForCall(errorNode);
         signatureContexts.forEach((context) => {
             // Use speculative mode to avoid emitting errors or caching types.
-            useSpeculativeMode(errorNode, () => {
-                const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, context, signatureTracker);
+            useSpeculativeMode(speculativeNode, () => {
+                const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, context);
                 if (!paramSpecArgResult.argumentErrors) {
                     filteredSignatureContexts.push(context);
                 }
@@ -8356,16 +8433,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             destTypeVarContext.copySignatureContexts(filteredSignatureContexts);
         }
         // Evaluate non-speculatively to produce a final result and cache types.
-        const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0], signatureTracker);
+        const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0]);
         return { argumentErrors: paramSpecArgResult.argumentErrors, typeVarContexts };
     }
-    function validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, signatureTracker) {
+    function validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext) {
         var _a;
         let paramSpecType = typeVarContext.getParamSpecType(paramSpec);
         if (!paramSpecType) {
             paramSpecType = (0, typeUtils_1.convertTypeToParamSpecValue)(paramSpec);
         }
-        const matchResults = matchArgsToParams(errorNode, argList, { type: paramSpecType }, 0, signatureTracker);
+        const matchResults = matchArgsToParams(errorNode, argList, { type: paramSpecType }, 0);
         const functionType = matchResults.overload;
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
         if (matchResults.argumentErrors) {
@@ -8392,7 +8469,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let argumentErrors = false;
             let argErrorNode;
             for (const arg of argList) {
-                const argType = (_a = getTypeOfArgument(arg, /* inferenceContext */ undefined, signatureTracker)) === null || _a === void 0 ? void 0 : _a.type;
+                const argType = (_a = getTypeOfArgument(arg, /* inferenceContext */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
                 if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
                     if ((0, parameterUtils_1.isParamSpecArgsArgument)(paramSpec, argType)) {
                         argsCount++;
@@ -8418,11 +8495,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return { argumentErrors, typeVarContexts: [srcTypeVarContext] };
         }
-        const result = validateArgTypes(errorNode, matchResults, srcTypeVarContext, signatureTracker, 
+        const result = validateArgTypes(errorNode, matchResults, srcTypeVarContext, 
         /* skipUnknownArgCheck */ undefined);
         return { argumentErrors: !!result.argumentErrors, typeVarContexts: [srcTypeVarContext] };
     }
-    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, options) {
+    function validateArgType(argParam, typeVarContext, typeResult, options) {
         var _a, _b;
         let argType;
         let expectedTypeDiag;
@@ -8477,12 +8554,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const flags = argParam.isinstanceParam
                     ? 536871546 /* EvalFlags.IsInstanceArgDefaults */
                     : 16 /* EvalFlags.NoFinal */ | 2 /* EvalFlags.NoSpecialize */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)), signatureTracker);
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
                 argType = exprTypeResult.type;
-                // If the type includes multiple instances of a generic function
-                // signature, force the type arguments for the duplicates to have
-                // unique names.
-                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker, argParam.argument.valueExpression.start);
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -8512,8 +8585,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 argType = argParam.argType;
             }
             else {
-                const argTypeResult = getTypeOfArgument(argParam.argument, 
-                /* inferenceContext */ undefined, signatureTracker);
+                const argTypeResult = getTypeOfArgument(argParam.argument, /* inferenceContext */ undefined);
                 argType = argTypeResult.type;
                 if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
@@ -8602,7 +8674,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let assignTypeFlags = skipSolveTypeVars ? 8 /* AssignTypeFlags.SkipSolveTypeVars */ : 0 /* AssignTypeFlags.Default */;
         if (argParam.isinstanceParam) {
-            assignTypeFlags |= 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */;
+            assignTypeFlags |= 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */;
         }
         if (!assignType(argParam.paramType, argType, diag.createAddendum(), typeVarContext, 
         /* srcTypeVarContext */ undefined, assignTypeFlags)) {
@@ -8704,7 +8776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let firstConstraintArg;
         let defaultValueNode;
         if (argList.length === 0) {
-            addError(localize_1.LocMessage.typeVarFirstArg(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), errorNode);
             return undefined;
         }
         const firstArg = argList[0];
@@ -8712,7 +8784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeVarName = firstArg.valueExpression.d.strings.map((s) => s.d.value).join('');
         }
         else {
-            addError(localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
         const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false), types_1.ClassType.cloneAsInstance(classType));
         // Parse the remaining parameters.
@@ -8722,18 +8794,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const paramName = paramNameNode ? paramNameNode.d.value : undefined;
             if (paramName) {
                 if (paramNameMap.get(paramName)) {
-                    addError(localize_1.LocMessage.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
                 }
                 if (paramName === 'bound') {
                     if (typeVar.shared.constraints.length > 0) {
-                        addError(localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.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, {
                             disallowProtocolAndTypedDict: true,
                         }).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true, ignoreImplicitTypeArgs: true })) {
-                            addError(localize_1.LocMessage.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
                         }
                         typeVar.shared.boundType = (0, typeUtils_1.convertToInstance)(argType);
                     }
@@ -8742,7 +8814,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
                         if (typeVar.shared.declaredVariance === 4 /* Variance.Contravariant */ ||
                             typeVar.shared.declaredVariance === 0 /* Variance.Auto */) {
-                            addError(localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
                             typeVar.shared.declaredVariance = 3 /* Variance.Covariant */;
@@ -8753,7 +8825,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
                         if (typeVar.shared.declaredVariance === 3 /* Variance.Covariant */ ||
                             typeVar.shared.declaredVariance === 0 /* Variance.Auto */) {
-                            addError(localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
                             typeVar.shared.declaredVariance = 4 /* Variance.Contravariant */;
@@ -8764,7 +8836,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
                         if (typeVar.shared.declaredVariance === 3 /* Variance.Covariant */ ||
                             typeVar.shared.declaredVariance === 4 /* Variance.Contravariant */) {
-                            addError(localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
                             typeVar.shared.declaredVariance = 0 /* Variance.Auto */;
@@ -8782,22 +8854,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
-                        addError(localize_1.LocMessage.typeVarDefaultIllegal(), defaultValueNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), defaultValueNode);
                     }
                 }
                 else {
-                    addError(localize_1.LocMessage.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.d.name) || argList[i].valueExpression || errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.d.name) || argList[i].valueExpression || errorNode);
                 }
                 paramNameMap.set(paramName, paramName);
             }
             else {
                 if (typeVar.shared.boundType) {
-                    addError(localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
                     const argType = (_g = (_f = argList[i].typeResult) === null || _f === void 0 ? void 0 : _f.type) !== null && _g !== void 0 ? _g : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true })) {
-                        addError(localize_1.LocMessage.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
                     }
                     types_1.TypeVarType.addConstraint(typeVar, (0, typeUtils_1.convertToInstance)(argType));
                     if (firstConstraintArg === undefined) {
@@ -8852,7 +8924,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a, _b;
         let typeVarName = '';
         if (argList.length === 0) {
-            addError(localize_1.LocMessage.typeVarFirstArg(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarFirstArg(), errorNode);
             return undefined;
         }
         const firstArg = argList[0];
@@ -8860,7 +8932,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeVarName = firstArg.valueExpression.d.strings.map((s) => s.d.value).join('');
         }
         else {
-            addError(localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
         const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false), types_1.ClassType.cloneAsInstance(classType));
         typeVar.shared.isVariadic = true;
@@ -8883,15 +8955,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
-                        addError(localize_1.LocMessage.typeVarDefaultIllegal(), expr);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
                 }
                 else {
-                    addError(localize_1.LocMessage.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.d.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.d.name) || argList[i].valueExpression || errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.d.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.d.name) || argList[i].valueExpression || errorNode);
                 }
             }
             else {
-                addError(localize_1.LocMessage.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
             }
         }
         return typeVar;
@@ -8912,7 +8984,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function createParamSpecType(errorNode, classType, argList) {
         if (argList.length === 0) {
-            addError(localize_1.LocMessage.paramSpecFirstArg(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecFirstArg(), errorNode);
             return undefined;
         }
         const firstArg = argList[0];
@@ -8921,7 +8993,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             paramSpecName = firstArg.valueExpression.d.strings.map((s) => s.d.value).join('');
         }
         else {
-            addError(localize_1.LocMessage.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
         }
         const paramSpec = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true), types_1.ClassType.cloneAsInstance(classType));
         paramSpec.shared.defaultType = (0, typeUtils_1.getUnknownTypeForParamSpec)();
@@ -8943,15 +9015,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!fileInfo.isStubFile &&
                         fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
-                        addError(localize_1.LocMessage.typeVarDefaultIllegal(), expr);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
                 }
                 else {
-                    addError(localize_1.LocMessage.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
                 }
             }
             else {
-                addError(localize_1.LocMessage.paramSpecUnknownArg(), argList[i].valueExpression || errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecUnknownArg(), argList[i].valueExpression || errorNode);
                 break;
             }
         }
@@ -9058,7 +9130,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let typeParameters;
         if (typeParamsExpr) {
             if (typeParamsExpr.nodeType !== 52 /* ParseNodeType.Tuple */) {
-                addError(localize_1.LocMessage.typeAliasTypeParamInvalid(), typeParamsExpr);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeParamInvalid(), typeParamsExpr);
                 return undefined;
             }
             typeParameters = [];
@@ -9187,16 +9259,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Implements the semantics of the multi-parameter variant of the "type" call.
     function createClassFromMetaclass(errorNode, argList, metaclass) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-        const arg0Type = getTypeOfArgument(argList[0], 
-        /* inferenceContext */ undefined, 
-        /* signatureTracker */ undefined).type;
+        const arg0Type = getTypeOfArgument(argList[0], /* inferenceContext */ undefined).type;
         if (!(0, types_1.isClassInstance)(arg0Type) || !types_1.ClassType.isBuiltIn(arg0Type, 'str')) {
             return undefined;
         }
         const className = arg0Type.priv.literalValue || '_';
-        const arg1Type = getTypeOfArgument(argList[1], 
-        /* inferenceContext */ undefined, 
-        /* signatureTracker */ undefined).type;
+        const arg1Type = getTypeOfArgument(argList[1], /* inferenceContext */ undefined).type;
         // TODO - properly handle case where tuple of base classes is provided.
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.priv.tupleTypeArguments === undefined) {
             return undefined;
@@ -9212,7 +9280,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
-            addError(localize_1.LocMessage.methodOrdering(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), errorNode);
         }
         return classType;
     }
@@ -9261,8 +9329,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, debug_1.assert)(magicMethodType !== undefined);
                     return validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                     /* typeVarContext */ undefined, 
-                    /* skipUnknownArgCheck */ true, inferenceContext, 
-                    /* signatureTracker */ undefined);
+                    /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 // If there were errors with the expected type, try
                 // to evaluate without the expected type.
@@ -9272,8 +9339,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ true, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     });
                 }
                 if (callResult.argumentErrors) {
@@ -9921,7 +9987,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     expectedYieldType = (0, typeUtils_1.getGeneratorYieldType)(returnType, !!enclosingFunction.d.isAsync);
                     const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(returnType);
                     if (generatorTypeArgs && generatorTypeArgs.length >= 2) {
-                        sentType = generatorTypeArgs[1];
+                        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        sentType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(generatorTypeArgs[1], liveScopeIds);
                     }
                 }
             }
@@ -10289,7 +10356,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function validateTypeArg(argResult, options) {
         if (argResult.typeList) {
             if (!(options === null || options === void 0 ? void 0 : options.allowTypeArgList)) {
-                addError(localize_1.LocMessage.typeArgListNotAllowed(), argResult.node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), argResult.node);
                 return false;
             }
             else {
@@ -10300,23 +10367,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((0, typeUtils_1.isEllipsisType)(argResult.type)) {
             if (!(options === null || options === void 0 ? void 0 : options.allowTypeArgList)) {
-                addError(localize_1.LocMessage.ellipsisContext(), argResult.node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), argResult.node);
                 return false;
             }
         }
         if ((0, types_1.isModule)(argResult.type)) {
-            addError(localize_1.LocMessage.moduleAsType(), argResult.node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.moduleAsType(), argResult.node);
             return false;
         }
         if ((0, types_1.isParamSpec)(argResult.type)) {
             if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
-                addError(localize_1.LocMessage.paramSpecContext(), argResult.node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), argResult.node);
                 return false;
             }
         }
         if ((0, types_1.isVariadicTypeVar)(argResult.type) && !argResult.type.priv.isVariadicInUnion) {
             if (!(options === null || options === void 0 ? void 0 : options.allowVariadicTypeVar)) {
-                addError(localize_1.LocMessage.typeVarTupleContext(), argResult.node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), argResult.node);
                 return false;
             }
             else {
@@ -10324,12 +10391,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowEmptyTuple) && argResult.isEmptyTupleShorthand) {
-            addError(localize_1.LocMessage.zeroLengthTupleNotAllowed(), argResult.node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.zeroLengthTupleNotAllowed(), argResult.node);
             return false;
         }
         if ((0, types_1.isUnpackedClass)(argResult.type)) {
             if (!(options === null || options === void 0 ? void 0 : options.allowUnpackedTuples)) {
-                addError(localize_1.LocMessage.unpackedArgInTypeArgument(), argResult.node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), argResult.node);
                 return false;
             }
         }
@@ -10355,7 +10422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Make sure we have at most one unpacked variadic type variable.
                     if (sawUnpacked) {
                         if (!reportedUnpackedError) {
-                            addError(localize_1.LocMessage.variadicTypeArgsTooMany(), entry.node);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), entry.node);
                             reportedUnpackedError = true;
                         }
                     }
@@ -10417,7 +10484,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else {
-                    addError(localize_1.LocMessage.callableFirstArg(), typeArgs[0].node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.callableFirstArg(), typeArgs[0].node);
                 }
             }
             if (typeArgs.length > 1) {
@@ -10432,7 +10499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 functionType.shared.declaredReturnType = types_1.UnknownType.create();
             }
             if (typeArgs.length > 2) {
-                addError(localize_1.LocMessage.callableExtraArgs(), typeArgs[2].node);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.callableExtraArgs(), typeArgs[2].node);
             }
         }
         else {
@@ -10451,13 +10518,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-                addError(localize_1.LocMessage.optionalExtraArgs(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.optionalExtraArgs(), errorNode);
                 return types_1.UnknownType.create();
             }
             return classType;
         }
         if (typeArgs.length > 1) {
-            addError(localize_1.LocMessage.optionalExtraArgs(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.optionalExtraArgs(), errorNode);
             return types_1.UnknownType.create();
         }
         let typeArg0Type = typeArgs[0].type;
@@ -10489,7 +10556,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Creates a type that represents a Literal.
     function createLiteralType(classType, node, flags) {
         if (node.d.items.length === 0) {
-            addError(localize_1.LocMessage.literalEmptyArgs(), node.d.leftExpr);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalEmptyArgs(), node.d.leftExpr);
             return types_1.UnknownType.create();
         }
         // As per the specification, we support None, int, bool, str, bytes literals
@@ -10499,11 +10566,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let type;
             const itemExpr = item.d.valueExpr;
             if (item.d.argCategory !== 0 /* ArgumentCategory.Simple */) {
-                addError(localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
                 type = types_1.UnknownType.create();
             }
             else if (item.d.name) {
-                addError(localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
                 type = types_1.UnknownType.create();
             }
             else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */) {
@@ -10572,7 +10639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (!type) {
-                addError(localize_1.LocMessage.literalUnsupportedType(), item);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
                 type = types_1.UnknownType.create();
             }
             literalTypes.push(type);
@@ -10587,18 +10654,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function createClassVarType(classType, errorNode, typeArgs, flags) {
         var _a;
         if (flags & 131072 /* EvalFlags.NoClassVar */) {
-            addError(localize_1.LocMessage.classVarNotAllowed(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarNotAllowed(), errorNode);
             return types_1.AnyType.create();
         }
         if (!typeArgs) {
             return classType;
         }
         else if (typeArgs.length === 0) {
-            addError(localize_1.LocMessage.classVarFirstArgMissing(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarFirstArgMissing(), errorNode);
             return types_1.UnknownType.create();
         }
         else if (typeArgs.length > 1) {
-            addError(localize_1.LocMessage.classVarTooManyArgs(), typeArgs[1].node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarTooManyArgs(), typeArgs[1].node);
             return types_1.UnknownType.create();
         }
         const type = typeArgs[0].type;
@@ -10619,12 +10686,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // we're in some other context.
         if (!typeArgs) {
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-                addError(localize_1.LocMessage.typeGuardArgCount(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeGuardArgCount(), errorNode);
             }
             return classType;
         }
         else if (typeArgs.length !== 1) {
-            addError(localize_1.LocMessage.typeGuardArgCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeGuardArgCount(), errorNode);
             return types_1.UnknownType.create();
         }
         const convertedTypeArgs = typeArgs.map((typeArg) => {
@@ -10684,7 +10751,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        return (0, typeUtils_1.synthesizeTypeVarForSelfCls)(enclosingClassTypeResult.classType, /* isClsParam */ true);
+        let result = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(enclosingClassTypeResult.classType, /* isClsParam */ true);
+        if (enclosingClass) {
+            // If "Self" is used as a type expression within a function suite, it needs
+            // to be marked as "internal".
+            const enclosingSuite = ParseTreeUtils.getEnclosingClassOrFunctionSuite(errorNode);
+            if (enclosingSuite && ParseTreeUtils.isNodeContainedWithin(enclosingSuite, enclosingClass)) {
+                if (enclosingClass.d.suite !== enclosingSuite) {
+                    result = types_1.TypeVarType.cloneWithInternalScopeId(result);
+                }
+            }
+        }
+        return result;
     }
     function createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
@@ -10694,7 +10772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { type: classType };
         }
         if (!typeArgs || typeArgs.length !== 1) {
-            addError(classType.shared.name === 'ReadOnly'
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
                 ? localize_1.LocMessage.readOnlyArgCount()
                 : classType.shared.name === 'Required'
                     ? localize_1.LocMessage.requiredArgCount()
@@ -10736,7 +10814,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isNotRequired = classType.shared.name === 'NotRequired';
         }
         if (!isUsageLegal) {
-            addError(classType.shared.name === 'ReadOnly'
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
                 ? localize_1.LocMessage.readOnlyNotInTypedDict()
                 : classType.shared.name === 'Required'
                     ? localize_1.LocMessage.requiredNotInTypedDict()
@@ -10753,7 +10831,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return classType;
         }
         if (!typeArgs || typeArgs.length !== 1) {
-            addError(localize_1.LocMessage.unpackArgCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackArgCount(), errorNode);
             return types_1.UnknownType.create();
         }
         let typeArgType = typeArgs[0].type;
@@ -10783,41 +10861,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Creates a "Final" type.
     function createFinalType(classType, errorNode, typeArgs, flags) {
         if (flags & 16 /* EvalFlags.NoFinal */) {
-            addError(localize_1.LocMessage.finalContext(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalContext(), errorNode);
             return classType;
         }
         if (!typeArgs || typeArgs.length === 0) {
             return classType;
         }
         if (typeArgs.length > 1) {
-            addError(localize_1.LocMessage.finalTooManyArgs(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalTooManyArgs(), errorNode);
         }
         return types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType);
     }
     function createConcatenateType(classType, errorNode, typeArgs, flags) {
         if ((flags & 134217728 /* EvalFlags.AllowConcatenate */) === 0) {
-            addError(localize_1.LocMessage.concatenateContext(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), errorNode);
             return types_1.AnyType.create();
         }
         if (!typeArgs || typeArgs.length === 0) {
-            addError(localize_1.LocMessage.concatenateTypeArgsMissing(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateTypeArgsMissing(), errorNode);
         }
         else {
             typeArgs.forEach((typeArg, index) => {
                 if (index === typeArgs.length - 1) {
                     if (!(0, types_1.isParamSpec)(typeArg.type) && !(0, typeUtils_1.isEllipsisType)(typeArg.type)) {
-                        addError(localize_1.LocMessage.concatenateParamSpecMissing(), typeArg.node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateParamSpecMissing(), typeArg.node);
                     }
                 }
                 else {
                     if ((0, types_1.isParamSpec)(typeArg.type)) {
-                        addError(localize_1.LocMessage.paramSpecContext(), typeArg.node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), typeArg.node);
                     }
                     else if ((0, types_1.isUnpackedVariadicTypeVar)(typeArg.type)) {
-                        addError(localize_1.LocMessage.typeVarTupleContext(), typeArg.node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), typeArg.node);
                     }
                     else if ((0, types_1.isUnpackedClass)(typeArg.type)) {
-                        addError(localize_1.LocMessage.unpackedArgInTypeArgument(), typeArg.node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), typeArg.node);
                     }
                 }
             });
@@ -10831,7 +10909,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if (typeArgs) {
             if (typeArgs.length < 2) {
-                addError(localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
             }
             else {
                 validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
@@ -10841,7 +10919,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { type: types_1.AnyType.create() };
         }
         if (typeArgs[0].typeList) {
-            addError(localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
         }
         return {
             type: types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType),
@@ -10873,8 +10951,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 ], { type: supportsTypeMethod }, 
                 /* typeVarContext */ undefined, 
                 /* skipUnknownArgCheck */ true, 
-                /* inferenceContext */ undefined, 
-                /* signatureTracker */ undefined));
+                /* inferenceContext */ undefined));
                 if (callResult.isTypeIncomplete || !callResult.returnType) {
                     continue;
                 }
@@ -10904,7 +10981,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const noteSawUnpacked = (typeArg) => {
                     if (sawUnpacked) {
                         if (!reportedUnpackedError) {
-                            addError(localize_1.LocMessage.variadicTypeArgsTooMany(), typeArg.node);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArg.node);
                             reportedUnpackedError = true;
                         }
                     }
@@ -10918,18 +10995,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         if (!isTupleTypeParam) {
                             if (!allowParamSpec) {
-                                addError(localize_1.LocMessage.ellipsisContext(), typeArg.node);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), typeArg.node);
                             }
                         }
                         else if (typeArgs.length !== 2 || index !== 1) {
-                            addError(localize_1.LocMessage.ellipsisSecondArg(), typeArg.node);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisSecondArg(), typeArg.node);
                         }
                         else {
                             if ((0, types_1.isVariadicTypeVar)(typeArgs[0].type) && !typeArgs[0].type.priv.isVariadicInUnion) {
-                                addError(localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
                             }
                             else if ((0, types_1.isUnpackedClass)(typeArgs[0].type)) {
-                                addError(localize_1.LocMessage.ellipsisAfterUnpacked(), typeArg.node);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisAfterUnpacked(), typeArg.node);
                             }
                         }
                     }
@@ -10958,7 +11035,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Make sure the argument list count is correct.
         if (paramLimit !== undefined) {
             if (typeArgs && typeArgTypes.length > paramLimit) {
-                addError(localize_1.LocMessage.typeArgsTooMany().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
                     name: classType.priv.aliasName || classType.shared.name,
                     expected: paramLimit,
                     received: typeArgTypes.length,
@@ -11015,7 +11092,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-                addError(localize_1.LocMessage.unionTypeArgCount(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unionTypeArgCount(), errorNode);
                 return types_1.NeverType.createNever();
             }
             return classType;
@@ -11079,7 +11156,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
             if ((flags & (256 /* EvalFlags.TypeExpression */ | 262144 /* EvalFlags.NoNakedGeneric */)) !== 0) {
-                addError(localize_1.LocMessage.genericTypeArgMissing(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgMissing(), errorNode);
             }
             return classType;
         }
@@ -11087,16 +11164,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (typeArgs) {
             // Make sure there's at least one type arg.
             if (typeArgs.length === 0) {
-                addError(localize_1.LocMessage.genericTypeArgMissing(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgMissing(), errorNode);
             }
             // Make sure that all of the type args are typeVars and are unique.
             typeArgs.forEach((typeArg) => {
                 if (!(0, types_1.isTypeVar)(typeArg.type)) {
-                    addError(localize_1.LocMessage.genericTypeArgTypeVar(), typeArg.node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgTypeVar(), typeArg.node);
                 }
                 else {
                     if (uniqueTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeArg.type))) {
-                        addError(localize_1.LocMessage.genericTypeArgUnique(), typeArg.node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgUnique(), typeArg.node);
                     }
                     uniqueTypeVars.push(typeArg.type);
                 }
@@ -11154,14 +11231,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Verify that we have at most one variadic type variable.
         const variadics = typeParameters.filter((param) => (0, types_1.isVariadicTypeVar)(param));
         if (variadics.length > 1) {
-            addError(localize_1.LocMessage.variadicTypeParamTooManyAlias().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeParamTooManyAlias().format({
                 names: variadics.map((v) => `"${v.shared.name}"`).join(', '),
             }), errorNode);
         }
         if (!isPep695Syntax && !isPep695TypeVarType) {
             const boundTypeVars = typeParameters.filter((typeVar) => typeVar.priv.scopeId !== typeAliasScopeId && typeVar.priv.scopeType === 0 /* TypeVarScopeType.Class */);
             if (boundTypeVars.length > 0) {
-                addError(localize_1.LocMessage.genericTypeAliasBoundTypeVar().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeAliasBoundTypeVar().format({
                     names: boundTypeVars.map((t) => `${t.shared.name}`).join(', '),
                 }), errorNode);
             }
@@ -11696,7 +11773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 if (!fileInfo.isStubFile &&
                                     !types_1.ClassType.isTypingExtensionClass(argType) &&
                                     fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_7)) {
-                                    addError(localize_1.LocMessage.protocolIllegal(), arg.d.valueExpr);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolIllegal(), arg.d.valueExpr);
                                 }
                                 classType.shared.flags |= 512 /* ClassTypeFlags.ProtocolClass */;
                             }
@@ -11723,14 +11800,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             // Validate that the class isn't deriving from itself, creating a
                             // circular dependency.
                             if ((0, typeUtils_1.derivesFromClassRecursive)(argType, classType, /* ignoreUnknown */ true)) {
-                                addError(localize_1.LocMessage.baseClassCircular(), arg);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassCircular(), arg);
                                 argType = types_1.UnknownType.create();
                             }
                             // If the class is attempting to derive from a TypeAliasType,
                             // generate an error.
                             if (((_c = argType.props) === null || _c === void 0 ? void 0 : _c.specialForm) &&
                                 types_1.ClassType.isBuiltIn(argType.props.specialForm, 'TypeAliasType')) {
-                                addError(localize_1.LocMessage.typeAliasTypeBaseClass(), arg);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeBaseClass(), arg);
                                 argType = types_1.UnknownType.create();
                             }
                         }
@@ -11765,7 +11842,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         if (types_1.ClassType.isFinal(argType)) {
                             const className = printObjectTypeForClass(argType);
-                            addError(localize_1.LocMessage.baseClassFinal().format({ type: className }), arg.d.valueExpr);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassFinal().format({ type: className }), arg.d.valueExpr);
                         }
                     }
                     (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(argType));
@@ -11808,7 +11885,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // PEP 589 specifies that the parameter must be either True or False.
                         const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
                         if (constArgValue === undefined) {
-                            addError(localize_1.LocMessage.typedDictBoolParam().format({ name: arg.d.name.d.value }), arg.d.valueExpr);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.d.name.d.value }), arg.d.valueExpr);
                         }
                         else if (arg.d.name.d.value === 'total' && !constArgValue) {
                             classType.shared.flags |= 32 /* ClassTypeFlags.CanOmitDictValues */;
@@ -11822,12 +11899,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                     else {
-                        addError(localize_1.LocMessage.typedDictInitsubclassParameter().format({ name: arg.d.name.d.value }), arg);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictInitsubclassParameter().format({ name: arg.d.name.d.value }), arg);
                     }
                 }
                 else if (arg.d.name.d.value === 'metaclass') {
                     if (metaclassNode) {
-                        addError(localize_1.LocMessage.metaclassDuplicate(), arg);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassDuplicate(), arg);
                     }
                     else {
                         metaclassNode = arg.d.valueExpr;
@@ -12053,7 +12130,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 });
                 if (foundInvalidBaseClass) {
-                    addError(localize_1.LocMessage.typedDictBaseClass() + diag.getString(), node.d.name);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBaseClass() + diag.getString(), node.d.name);
                 }
                 (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType);
             }
@@ -12348,13 +12425,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function completeClassTypeDeferred(type, errorNode) {
         // Recompute the MRO linearization.
         if (!(0, typeUtils_1.computeMroLinearization)(type)) {
-            addError(localize_1.LocMessage.methodOrdering(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), errorNode);
         }
         // Recompute the effective metaclass.
         computeEffectiveMetaclass(type, errorNode);
     }
     function validateInitSubclassArgs(node, classType) {
-        var _a, _b;
         // Collect arguments that will be passed to the `__init_subclass__`
         // method described in PEP 487 and validate it.
         const argList = [];
@@ -12368,7 +12444,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
             }
         });
-        const errorNode = argList.length > 0 ? (_b = (_a = argList[0].node) === null || _a === void 0 ? void 0 : _a.d.valueExpr) !== null && _b !== void 0 ? _b : node.d.name : node.d.name;
         let newMethodMember;
         // See if the class has a metaclass that overrides `__new__`. If so, we
         // will validate the signature of the `__new__` method.
@@ -12399,7 +12474,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     argList.forEach((arg) => {
                         var _a, _b, _c;
-                        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
                         if (arg.argumentCategory === 0 /* ArgumentCategory.Simple */ && arg.name) {
                             const paramIndex = (_a = paramMap.get(arg.name.d.value)) !== null && _a !== void 0 ? _a : paramListDetails.kwargsIndex;
                             if (paramIndex !== undefined) {
@@ -12409,13 +12483,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     paramType: paramInfo.type,
                                     requiresTypeVarMatching: false,
                                     argument: arg,
-                                    errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
+                                    errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : node.d.name,
                                 };
-                                validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
+                                validateArgType(argParam, new typeVarContext_1.TypeVarContext(), { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
                                 paramMap.delete(arg.name.d.value);
                             }
                             else {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramNameMissing().format({ name: arg.name.d.value }), (_c = arg.name) !== null && _c !== void 0 ? _c : errorNode);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramNameMissing().format({ name: arg.name.d.value }), (_c = arg.name) !== null && _c !== void 0 ? _c : node.d.name);
                             }
                         }
                     });
@@ -12432,7 +12506,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
                             ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
-                            : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), errorNode);
+                            : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), node.d.name);
                     }
                 }
             }
@@ -12440,7 +12514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             // If there was no custom metaclass __new__ method, see if there is an __init_subclass__
             // method present somewhere in the class hierarchy.
-            const initSubclassMethodInfo = getTypeOfBoundMember(errorNode, classType, '__init_subclass__', 
+            const initSubclassMethodInfo = getTypeOfBoundMember(node.d.name, classType, '__init_subclass__', 
             /* usage */ undefined, 
             /* diag */ undefined, 32 /* MemberAccessFlags.SkipClassMembers */ |
                 1 /* MemberAccessFlags.SkipOriginalClass */ |
@@ -12448,10 +12522,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (initSubclassMethodInfo) {
                 const initSubclassMethodType = initSubclassMethodInfo.type;
                 if (initSubclassMethodType && initSubclassMethodInfo.classType) {
-                    const callResult = validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
+                    const callResult = validateCallArguments(node.d.name, argList, { type: initSubclassMethodType }, 
                     /* typeVarContext */ undefined, 
-                    /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()), 
-                    /* signatureTracker */ undefined);
+                    /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
                     if (callResult.argumentErrors) {
                         const diag = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initSubclassCallFailed(), node.d.name);
                         const initSubclassFunction = (0, types_1.isOverloadedFunction)(initSubclassMethodType)
@@ -12620,7 +12693,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     firstCommentAnnotationIndex = 0;
                 }
                 else if (received !== expected) {
-                    addError(localize_1.LocMessage.annotatedParamCountMismatch().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotatedParamCountMismatch().format({
                         expected,
                         received,
                     }), node.d.funcAnnotationComment);
@@ -12682,7 +12755,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(annotatedType), functionType.shared.typeVarScopeId);
                     }
                     if ((0, types_1.isVariadicTypeVar)(annotatedType) && !annotatedType.priv.isVariadicUnpacked) {
-                        addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                             name1: annotatedType.shared.name,
                             name2: annotatedType.shared.name,
                         }), paramTypeNode);
@@ -12794,12 +12867,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
             }
             // Update the types for the nodes associated with the parameters.
+            const scopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
             paramTypes.forEach((paramType, index) => {
                 const paramNameNode = node.d.params[index].d.name;
                 if (paramNameNode) {
                     if ((0, types_1.isUnknown)(paramType)) {
                         functionType.shared.flags |= 16384 /* FunctionTypeFlags.UnannotatedParams */;
                     }
+                    paramType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(paramType, scopeIds);
                     writeTypeCache(paramNameNode, { type: paramType }, 0 /* EvalFlags.None */);
                 }
             });
@@ -13932,9 +14007,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Return expressions must be evaluated in the context of the expected return type.
                 if (parent.d.expr) {
                     const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-                    const declaredReturnType = enclosingFunctionNode
+                    let declaredReturnType = enclosingFunctionNode
                         ? getFunctionDeclaredReturnType(enclosingFunctionNode)
                         : undefined;
+                    if (declaredReturnType) {
+                        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopeIds);
+                    }
                     getTypeOfExpression(parent.d.expr, 0 /* EvalFlags.None */, (0, typeUtils_1.makeInferenceContext)(declaredReturnType));
                     return;
                 }
@@ -13956,6 +14035,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getTypeOfExpression(nodeToEvaluate, flags);
     }
     function evaluateTypeOfParameter(node) {
+        var _a;
         // If this parameter has no name, we have nothing to do.
         if (!node.d.name) {
             return;
@@ -13988,7 +14068,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const typeParamName = getPseudoGenericTypeVarName(node.d.name.d.value);
             const paramType = classInfo.classType.shared.typeParameters.find((param) => param.shared.name === typeParamName);
             if (paramType) {
-                writeTypeCache(node.d.name, { type: paramType }, 0 /* EvalFlags.None */);
+                writeTypeCache(node.d.name, { type: types_1.TypeVarType.cloneWithInternalScopeId(paramType) }, 0 /* EvalFlags.None */);
                 return;
             }
         }
@@ -13997,8 +14077,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // a parent class if it has an annotated type.
         const functionFlags = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, functionNode, 
         /* isInClass */ true).flags;
-        const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
-        writeTypeCache(node.d.name, { type: transformVariadicParamType(node, node.d.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* EvalFlags.None */);
+        let inferredParamType = (_a = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+        inferredParamType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(inferredParamType, liveTypeVarScopes);
+        writeTypeCache(node.d.name, { type: transformVariadicParamType(node, node.d.category, inferredParamType) }, 0 /* EvalFlags.None */);
     }
     // Evaluates the types that are assigned within the statement that contains
     // the specified parse node. In some cases, a broader statement may need to
@@ -14209,13 +14291,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 case 'Never': {
                     if (typeArgs && typeArgs.length > 0) {
-                        addError(localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'Never' }), typeArgs[0].node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'Never' }), typeArgs[0].node);
                     }
                     return { type: types_1.NeverType.createNever() };
                 }
                 case 'NoReturn': {
                     if (typeArgs && typeArgs.length > 0) {
-                        addError(localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'NoReturn' }), typeArgs[0].node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'NoReturn' }), typeArgs[0].node);
                     }
                     return { type: types_1.NeverType.createNoReturn() };
                 }
@@ -14236,11 +14318,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 case 'Protocol': {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
-                        addError(localize_1.LocMessage.protocolNotAllowed(), errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolNotAllowed(), errorNode);
                     }
                     typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.forEach((typeArg) => {
                         if (typeArg.typeList || !(0, types_1.isTypeVar)(typeArg.type)) {
-                            addError(localize_1.LocMessage.protocolTypeArgMustBeTypeParam(), typeArg.node);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolTypeArgMustBeTypeParam(), typeArg.node);
                         }
                     });
                     return {
@@ -14251,13 +14333,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 case 'TypedDict': {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
-                        addError(localize_1.LocMessage.typedDictNotAllowed(), errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
                     }
                     break;
                 }
                 case 'Literal': {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
-                        addError(localize_1.LocMessage.literalNotAllowed(), errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNotAllowed(), errorNode);
                     }
                     break;
                 }
@@ -14426,11 +14508,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (typeArgs.length > 1) {
                 const paramSpecTypeArg = typeArgs.find((typeArg) => (0, types_1.isParamSpec)(typeArg.type));
                 if (paramSpecTypeArg) {
-                    addError(localize_1.LocMessage.paramSpecContext(), paramSpecTypeArg.node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), paramSpecTypeArg.node);
                 }
                 const listTypeArg = typeArgs.find((typeArg) => !!typeArg.typeList);
                 if (listTypeArg) {
-                    addError(localize_1.LocMessage.typeArgListNotAllowed(), listTypeArg.node);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), listTypeArg.node);
                 }
             }
         }
@@ -14538,7 +14620,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         return { type: specializedClass };
     }
-    function getTypeOfArgument(arg, inferenceContext, signatureTracker) {
+    function getTypeOfArgument(arg, inferenceContext) {
         var _a, _b;
         if (arg.typeResult) {
             const type = arg.typeResult.type;
@@ -14550,12 +14632,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
-        const typeResult = getTypeOfExpression(arg.valueExpression, 
-        /* flags */ undefined, inferenceContext, signatureTracker);
-        if (signatureTracker) {
-            typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, arg.valueExpression.start);
-        }
-        return typeResult;
+        return getTypeOfExpression(arg.valueExpression, /* flags */ undefined, inferenceContext);
     }
     // This function is like getTypeOfArgument except that it is
     // used in cases where the argument is expected to be a type
@@ -14746,6 +14823,50 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             throw e;
         }
     }
+    function getSignatureTrackerForNode(node) {
+        for (let i = signatureTrackerStack.length - 1; i >= 0; i--) {
+            const rootNode = signatureTrackerStack[i].rootNode;
+            if (ParseTreeUtils.isNodeContainedWithin(node, rootNode)) {
+                return signatureTrackerStack[i].tracker;
+            }
+        }
+        return undefined;
+    }
+    function useSignatureTracker(node, callback) {
+        const tracker = getSignatureTrackerForNode(node);
+        try {
+            // If a signature tracker doesn't already exist, allocate one.
+            if (!tracker) {
+                signatureTrackerStack.push({
+                    tracker: new typeUtils_1.UniqueSignatureTracker(),
+                    rootNode: node,
+                });
+            }
+            const result = callback();
+            if (!tracker) {
+                signatureTrackerStack.pop();
+            }
+            return result;
+        }
+        catch (e) {
+            // We don't use finally here because the TypeScript debugger doesn't
+            // handle finally well when single stepping.
+            if (!tracker) {
+                signatureTrackerStack.pop();
+            }
+            throw e;
+        }
+    }
+    function ensureSignatureIsUnique(type, node) {
+        const tracker = getSignatureTrackerForNode(node);
+        if (!tracker) {
+            return type;
+        }
+        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type)) {
+            return (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(type, tracker, node.start);
+        }
+        return type;
+    }
     // Disables recording of errors and warnings and disables any caching of
     // types, under the assumption that we're performing speculative evaluations.
     // If speculativeNode is undefined, speculative mode is not used. This is
@@ -14949,8 +15070,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         else if (node.parent && node.parent.nodeType === 1 /* ParseNodeType.Argument */ && node === node.parent.d.name) {
-            // The target node is the name in a named argument. We need to determine whether
-            // the corresponding named parameter can be determined from the context.
+            // The target node is the name in a keyword argument. We need to determine whether
+            // the corresponding keyword parameter can be determined from the context.
             const argNode = node.parent;
             const paramName = node.d.value;
             if (((_a = argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
@@ -15089,7 +15210,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 if (typeAnnotationNode) {
-                    const declaredType = getTypeOfParameterAnnotation(typeAnnotationNode, declaration.node.d.category);
+                    let declaredType = getTypeOfParameterAnnotation(typeAnnotationNode, declaration.node.d.category);
+                    const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(declaration.node);
+                    declaredType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredType, liveTypeVarScopes);
                     return {
                         type: transformVariadicParamType(declaration.node, declaration.node.d.category, adjustParameterAnnotatedType(declaration.node, declaredType)),
                     };
@@ -15119,9 +15242,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
                             allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
                             allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
+                            enforceClassTypeVarScope: declaration.isDefinedByMemberAccess,
                         });
                     }
                     if (declaredType) {
+                        // If this is a declaration for a member variable within a method,
+                        // we need to convert any "internal" TypeVars associated with the
+                        // class to their "external" counterparts.
+                        if (declaration.isDefinedByMemberAccess) {
+                            const enclosingClass = ParseTreeUtils.getEnclosingClass(declaration.node);
+                            if (enclosingClass) {
+                                declaredType = (0, typeUtils_1.updateTypeWithExternalTypeVars)(declaredType, [
+                                    ParseTreeUtils.getScopeIdForNode(enclosingClass),
+                                ]);
+                            }
+                        }
                         if ((0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias')) {
                             return { type: undefined, isTypeAlias: true };
                         }
@@ -15173,7 +15308,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         ignorePseudoGeneric: true,
                         ignoreImplicitTypeArgs: true,
                     })) {
-                        addError(localize_1.LocMessage.typeVarBoundGeneric(), constraint);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundGeneric(), constraint);
                     }
                     return (0, typeUtils_1.convertToInstance)(constraintType);
                 });
@@ -15190,7 +15325,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     allowForwardReference: true,
                 }).type;
                 if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
-                    addError(localize_1.LocMessage.typeVarConstraintGeneric(), node.d.boundExpr);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarConstraintGeneric(), node.d.boundExpr);
                 }
                 if (node.d.typeParamKind === parseNodes_1.TypeParameterKind.TypeVar) {
                     typeVar.shared.boundType = (0, typeUtils_1.convertToInstance)(boundType);
@@ -15856,7 +15991,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return types_1.UnknownType.create();
     }
     function _getFunctionInferredReturnType(type, callSiteInfo) {
-        var _a;
+        var _a, _b, _c;
         let returnType;
         let isIncomplete = false;
         const analyzeUnannotatedFunctions = true;
@@ -15909,6 +16044,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!returnType) {
                 returnType = types_1.UnknownType.create();
             }
+            // Externalize any TypeVars that appear in the type.
+            const typeVarScopes = [];
+            if (type.shared.typeVarScopeId) {
+                typeVarScopes.push(type.shared.typeVarScopeId);
+            }
+            if ((_a = type.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId) {
+                typeVarScopes.push(type.shared.methodClass.shared.typeVarScopeId);
+            }
+            returnType = (0, typeUtils_1.updateTypeWithExternalTypeVars)(returnType, typeVarScopes);
             // Cache the type for next time.
             if (!isIncomplete) {
                 type.priv.inferredReturnType = returnType;
@@ -15926,7 +16070,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             callSiteInfo) {
             let hasDecorators = false;
             let isAsync = false;
-            const declNode = (_a = type.shared.declaration) === null || _a === void 0 ? void 0 : _a.node;
+            const declNode = (_b = type.shared.declaration) === null || _b === void 0 ? void 0 : _b.node;
             if (declNode) {
                 if (declNode.d.decorators.length > 0) {
                     hasDecorators = true;
@@ -15941,6 +16085,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, callSiteInfo);
                 if (contextualReturnType) {
                     returnType = contextualReturnType;
+                    if ((_c = type.shared.declaration) === null || _c === void 0 ? void 0 : _c.node) {
+                        // Externalize any TypeVars that appear in the type.
+                        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(type.shared.declaration.node);
+                        returnType = (0, typeUtils_1.updateTypeWithExternalTypeVars)(returnType, liveScopeIds);
+                    }
                 }
             }
         }
@@ -16083,26 +16232,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    // If the function has an explicitly-declared return type, it is returned
+    // unaltered unless the function is a generator, in which case it is
+    // modified to return only the return type for the generator.
     function getFunctionDeclaredReturnType(node) {
         const functionTypeInfo = getTypeOfFunction(node);
-        if (!functionTypeInfo) {
-            // We hit a recursive dependency.
-            return types_1.AnyType.create();
-        }
-        // Ignore this check for abstract methods, which often
-        // don't actually return any value.
-        if (types_1.FunctionType.isAbstractMethod(functionTypeInfo.functionType)) {
-            return types_1.AnyType.create();
+        const returnType = functionTypeInfo === null || functionTypeInfo === void 0 ? void 0 : functionTypeInfo.functionType.shared.declaredReturnType;
+        if (!returnType) {
+            return undefined;
         }
         if (types_1.FunctionType.isGenerator(functionTypeInfo.functionType)) {
             return (0, typeUtils_1.getDeclaredGeneratorReturnType)(functionTypeInfo.functionType);
         }
-        return functionTypeInfo.functionType.shared.declaredReturnType;
+        return returnType;
     }
     function getTypeOfMember(member) {
         if ((0, types_1.isInstantiableClass)(member.classType)) {
-            return (0, typeUtils_1.partiallySpecializeType)(getEffectiveTypeOfSymbol(member.symbol), member.classType, 
-            /* selfClass */ undefined, typeClass && (0, types_1.isInstantiableClass)(typeClass) ? typeClass : undefined);
+            return (0, typeUtils_1.partiallySpecializeType)(getEffectiveTypeOfSymbol(member.symbol), member.classType, getTypeClassType(), 
+            /* selfClass */ undefined);
         }
         return types_1.UnknownType.create();
     }
@@ -16136,7 +16283,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             (0, types_1.isClass)(member.unspecializedClassType) &&
             (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
             (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
-            const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
+            const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, getTypeClassType(), (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
             if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) &&
                 !(0, types_1.isOverloadedFunction)(subtype) &&
                 (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
@@ -16144,7 +16291,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         return {
-            type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, selfClass),
+            type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, getTypeClassType(), selfClass),
             isIncomplete: !!typeResult.isIncomplete,
         };
     }
@@ -16295,7 +16442,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 (0, debug_1.assert)(memberInfo !== undefined);
                 let destMemberType = getEffectiveTypeOfSymbol(symbol);
                 const srcMemberType = getTypeOfMember(memberInfo);
-                destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
+                destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType, getTypeClassType());
                 // Properties require special processing.
                 if ((0, types_1.isClassInstance)(destMemberType) &&
                     types_1.ClassType.isPropertyClass(destMemberType) &&
@@ -16323,7 +16470,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     if (!assignType(destMemberType, srcMemberType, 
                     /* diag */ undefined, typeVarContext, 
-                    /* srcTypeVarContext */ undefined, flags | 65536 /* AssignTypeFlags.IgnoreSelfClsParamCompatibility */, recursionCount)) {
+                    /* srcTypeVarContext */ undefined, flags | 32768 /* AssignTypeFlags.SkipSelfClsParamCheck */, recursionCount)) {
                         isAssignable = false;
                     }
                 }
@@ -16771,7 +16918,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let isSpecialFormExempt = false;
             // A few special forms that are normally not compatible with type[T]
             // are compatible specifically in the context of isinstance and issubclass.
-            if ((flags & 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+            if ((flags & 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
                 if (types_1.ClassType.isBuiltIn(specialForm, ['Callable', 'UnionType', 'Generic'])) {
                     isSpecialFormExempt = true;
                 }
@@ -16841,11 +16988,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnbound)(destType) || (0, types_1.isUnbound)(srcType)) {
             return true;
         }
-        // If we're in "overload overlap" mode, convert top-level type variables
-        // to their concrete forms in the source.
-        if ((flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) !== 0) {
-            srcType = makeTopLevelTypeVarsConcrete(srcType);
-        }
         // Strip flags we don't want to propagate to other calls.
         const originalFlags = flags;
         flags &= ~128 /* AssignTypeFlags.AllowBoolTypeGuard */;
@@ -16891,6 +17033,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 srcType.shared.boundType &&
                 destType.shared.isSynthesizedSelf &&
                 destType.shared.boundType &&
+                types_1.TypeVarType.hasInternalScopeId(destType) === types_1.TypeVarType.hasInternalScopeId(srcType) &&
                 types_1.TypeBase.isInstance(srcType) === types_1.TypeBase.isInstance(destType)) {
                 if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 && destTypeVarContext) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, originalFlags, recursionCount);
@@ -16913,7 +17056,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!(0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, targetTypeVarContext !== null && targetTypeVarContext !== void 0 ? targetTypeVarContext : new typeVarContext_1.TypeVarContext(), originalFlags, recursionCount)) {
                     return false;
                 }
-                if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) !== 0) {
+                if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0) {
                     return false;
                 }
                 return true;
@@ -16989,7 +17132,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const typeVarSubstitution = (0, typeUtils_1.isEllipsisType)(srcType) ? types_1.AnyType.create() : srcType;
                 (0, typeUtils_1.setTypeArgumentsRecursive)(destType, typeVarSubstitution, targetTypeVarContext, recursionCount);
             }
-            if ((flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) === 0) {
+            if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0) {
                 return true;
             }
         }
@@ -17077,8 +17220,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isInstantiableClass)(expandedSrcType)) {
                 // PEP 544 says that if the dest type is a type[Proto] class,
                 // the source must be a "concrete" (non-protocol) class.
-                if (types_1.ClassType.isProtocolClass(destType) &&
-                    (flags & 16384 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
+                if (types_1.ClassType.isProtocolClass(destType)) {
                     if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.priv.includeSubclasses) {
@@ -17123,7 +17265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((0, types_1.isInstantiableClass)(srcType) && isSpecialFormClass(srcType, flags)) {
                     return false;
                 }
-                if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) !== 0) {
+                if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0) {
                     return false;
                 }
                 const destTypeArgs = destType.priv.typeArguments;
@@ -17185,6 +17327,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Is the destination a callback protocol (defined in PEP 544)?
                 const destCallbackType = getCallbackProtocolType(destType, recursionCount);
                 if (destCallbackType) {
+                    if (destTypeVarContext) {
+                        destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destCallbackType));
+                    }
                     return assignType(destCallbackType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
                 // All functions are considered instances of "builtins.function".
@@ -17226,7 +17371,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !((_j = concreteSrcType.props) === null || _j === void 0 ? void 0 : _j.specialForm)) {
-                return (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) === 0;
+                return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
             else if ((0, types_1.isUnion)(concreteSrcType)) {
                 return assignType(destType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
@@ -17255,7 +17400,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if ((0, types_1.isAnyOrUnknown)(concreteSrcType)) {
-                return (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) === 0;
+                return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
             if ((0, types_1.isOverloadedFunction)(concreteSrcType)) {
                 // Find all of the overloaded functions that match the parameters.
@@ -17507,7 +17652,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // If we're looking for type overlaps and at least one type was matched,
             // consider it as assignable.
-            if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */) !== 0 && matchedSomeSubtypes) {
+            if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0 && matchedSomeSubtypes) {
                 return true;
             }
         }
@@ -17535,7 +17680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (isIncompatible) {
             // If we're looking for type overlaps and at least one type was matched,
             // consider it as assignable.
-            if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */) !== 0 && matchedSomeSubtypes) {
+            if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0 && matchedSomeSubtypes) {
                 return true;
             }
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -17544,7 +17689,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return true;
     }
     function isSpecialFormClass(classType, flags) {
-        if ((flags & 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+        if ((flags & 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
             return false;
         }
         return types_1.ClassType.isSpecialFormClass(classType);
@@ -17802,13 +17947,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let specializedSrcType = srcType;
         let specializedDestType = destType;
         let doSpecializationStep = false;
-        if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
-            specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, { useNarrowBoundOnly: true });
-            doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedDestType);
-        }
-        else {
-            specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, { useNarrowBoundOnly: true });
-            doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedSrcType);
+        if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0) {
+            if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
+                specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, { useNarrowBoundOnly: true });
+                doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedDestType);
+            }
+            else {
+                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, { useNarrowBoundOnly: true });
+                doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedSrcType);
+            }
         }
         // Is an additional specialization step required?
         if (doSpecializationStep) {
@@ -17913,9 +18060,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function assignFunction(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         let canAssign = true;
-        const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
+        const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipReturnTypeCheck */) === 0;
         const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
-        flags &= ~64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */;
+        flags &= ~64 /* AssignTypeFlags.SkipReturnTypeCheck */;
         const destParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(destType);
         if (destParamSpec) {
             destType = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(destType);
@@ -17935,7 +18082,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         for (let paramIndex = 0; paramIndex < positionalsToMatch; paramIndex++) {
             if (paramIndex === 0 &&
                 destType.shared.methodClass &&
-                (flags & 65536 /* AssignTypeFlags.IgnoreSelfClsParamCompatibility */) !== 0) {
+                (flags & 32768 /* AssignTypeFlags.SkipSelfClsParamCheck */) !== 0) {
                 if (types_1.FunctionType.isInstanceMethod(destType) || types_1.FunctionType.isClassMethod(destType)) {
                     continue;
                 }
@@ -18461,10 +18608,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // consistent and probably not sound from a type theory perspective. It
         // should be completely reworked once there has been a public discussion
         // about the correct behavior.
-        // If the result is incomplete, do not attempt to narrow the type.
-        if (assignedTypeResult.isIncomplete) {
-            return assignedTypeResult;
-        }
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedTypeResult.type, (assignedSubtype) => {
             // Handle the special case where the assigned type is a literal type.
             // Some types include very large unions of literal types, and we don't
@@ -18997,10 +19140,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let bestConstraintSoFar;
             // Try to find the best (narrowest) match among the constraints.
             for (const constraint of constraints) {
-                // Don't allow Never as a type argument.
-                if (assignType(constraint, effectiveSrcType) && !(0, types_1.isNever)(effectiveSrcType)) {
-                    if (!bestConstraintSoFar || assignType(bestConstraintSoFar, constraint)) {
-                        bestConstraintSoFar = constraint;
+                if (assignType(constraint, effectiveSrcType)) {
+                    // Don't allow Never to match unless the constraint is also explicitly Never.
+                    if (!(0, types_1.isNever)(effectiveSrcType) || (0, types_1.isNever)(constraint)) {
+                        if (!bestConstraintSoFar || assignType(bestConstraintSoFar, constraint)) {
+                            bestConstraintSoFar = constraint;
+                        }
                     }
                 }
             }
@@ -19069,18 +19214,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (memberClass && (0, typeUtils_1.isInstantiableMetaclass)(memberClass)) {
                     stripFirstParam = true;
                 }
-                return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, stripFirstParam);
+                return partiallySpecializeBoundMethod(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, stripFirstParam);
             }
             if (types_1.FunctionType.isClassMethod(functionType) ||
                 (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
-                return partiallySpecializeFunctionForBoundClassOrObject(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
+                return partiallySpecializeBoundMethod(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
                 /* stripFirstParam */ true);
             }
             if (types_1.FunctionType.isStaticMethod(functionType)) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
-                return partiallySpecializeFunctionForBoundClassOrObject(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, 
+                return partiallySpecializeBoundMethod(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, 
                 /* firstParamType */ undefined, 
                 /* stripFirstParam */ false);
             }
@@ -19093,7 +19238,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // is the type used to reference the member, and the memberClass
     // is the class that provided the member (could be an ancestor of
     // the baseType's class).
-    function partiallySpecializeFunctionForBoundClassOrObject(baseType, memberType, memberClass, diag, recursionCount, firstParamType, stripFirstParam = true) {
+    function partiallySpecializeBoundMethod(baseType, memberType, memberClass, diag, recursionCount, firstParamType, stripFirstParam = true) {
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(memberClass));
         if (firstParamType && memberType.shared.parameters.length > 0) {
             const memberTypeFirstParam = memberType.shared.parameters[0];
@@ -19337,7 +19482,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
         if (parseResults.parseTree && parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */) {
             parseResults.diagnostics.forEach((diag) => {
-                addError(diag.message, node);
+                addDiagnosticWithSuppressionCheck('error', diag.message, node);
             });
             parseResults.parseTree.parent = node;
             return parseResults.parseTree;
@@ -19403,7 +19548,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         removeFalsinessFromType,
         verifyRaiseExceptionType,
         verifyDeleteExpression,
-        validateOverloadedFunctionArguments,
+        validateOverloadedArgTypes,
         validateInitSubclassArgs,
         isAfterNodeReachable,
         isNodeReachable,
@@ -19453,6 +19598,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getObjectType,
         getNoneType,
         getUnionClassType,
+        getTypeClassType,
         getBuiltInObject,
         getTypingType,
         assignTypeArguments,