@zzzen/pyright-internal 1.2.0-dev.20240728 → 1.2.0-dev.20240804

package/dist/analyzer/checker.js

@@ -50,6 +50,7 @@ const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declaration_1 = require("./declaration");
@@ -69,13 +70,12 @@ const sourceMapper_1 = require("./sourceMapper");
 const staticExpressions_1 = require("./staticExpressions");
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
+const typedDicts_1 = require("./typedDicts");
 const typeEvaluator_1 = require("./typeEvaluator");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
-const typeUtils_1 = require("./typeUtils");
-const typeVarContext_1 = require("./typeVarContext");
-const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
 // When enabled, this debug flag causes the code complexity of
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
@@ -248,14 +248,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // Allow unknown and missing param types if the param is named '_'.
                 if (param.d.name && param.d.name.d.value !== '_') {
-                    const functionTypeParam = functionTypeResult.functionType.shared.parameters.find((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
-                    if (functionTypeParam) {
-                        const paramType = functionTypeParam.type;
+                    const paramIndex = functionTypeResult.functionType.shared.parameters.findIndex((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
+                    if (paramIndex >= 0) {
+                        const functionTypeParam = functionTypeResult.functionType.shared.parameters[paramIndex];
+                        const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, paramIndex);
                         if (this._fileInfo.diagnosticRuleSet.reportUnknownParameterType !== 'none') {
                             if ((0, types_1.isUnknown)(paramType) ||
                                 ((0, types_1.isTypeVar)(paramType) &&
                                     paramType.shared.isSynthesized &&
-                                    !paramType.shared.isSynthesizedSelf)) {
+                                    !types_1.TypeVarType.isSelf(paramType))) {
                                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.d.name.d.value }), param.d.name);
                             }
                             else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
@@ -274,7 +275,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         else {
                             // See if this is a "self" and "cls" parameter. They are exempt from this rule.
-                            if ((0, types_1.isTypeVar)(paramType) && paramType.shared.isSynthesizedSelf) {
+                            if ((0, types_1.isTypeVar)(paramType) && types_1.TypeVarType.isSelf(paramType)) {
                                 hasAnnotation = true;
                             }
                         }
@@ -287,7 +288,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Verify that an unpacked TypedDict doesn't overlap any keyword parameters.
             if (paramDetails.hasUnpackedTypedDict) {
                 const kwargsIndex = functionTypeResult.functionType.shared.parameters.length - 1;
-                const kwargsType = types_1.FunctionType.getEffectiveParamType(functionTypeResult.functionType, kwargsIndex);
+                const kwargsType = types_1.FunctionType.getParamType(functionTypeResult.functionType, kwargsIndex);
                 if ((0, types_1.isClass)(kwargsType) && kwargsType.shared.typedDictEntries) {
                     const overlappingEntries = new Set();
                     kwargsType.shared.typedDictEntries.knownItems.forEach((_, name) => {
@@ -303,9 +304,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             // Check for invalid use of ParamSpec P.args and P.kwargs.
-            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param) => {
-                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
-                    if (param.category !== 0 /* ParamCategory.Simple */ && param.name && param.type.priv.paramSpecAccess) {
+            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param, index) => {
+                const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, index);
+                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(paramType) && (0, types_1.isParamSpec)(paramType)) {
+                    if (param.category !== 0 /* ParamCategory.Simple */ && param.name && paramType.priv.paramSpecAccess) {
                         return true;
                     }
                 }
@@ -343,10 +345,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (functionTypeResult) {
                 const annotationNode = param.d.annotation || param.d.annotationComment;
                 if (annotationNode && index < functionTypeResult.functionType.shared.parameters.length) {
-                    const paramType = functionTypeResult.functionType.shared.parameters[index].type;
+                    const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, index);
                     const exemptMethods = ['__init__', '__new__'];
                     if (containingClassNode &&
                         (0, types_1.isTypeVar)(paramType) &&
+                        paramType.priv.scopeType === 0 /* TypeVarScopeType.Class */ &&
                         paramType.shared.declaredVariance === 3 /* Variance.Covariant */ &&
                         !paramType.shared.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.shared.name)) {
@@ -579,33 +582,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else {
                     const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-                    declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
                     declaredReturnType = this._evaluator.stripTypeGuard(declaredReturnType);
+                    let adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
-                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
-                    /* destTypeVarContext */ new typeVarContext_1.TypeVarContext())) {
+                    if (this._evaluator.assignType(adjReturnType, returnType, diagAddendum)) {
                         returnTypeMatches = true;
                     }
                     else {
                         // See if the declared return type includes one or more constrained TypeVars. If so,
                         // try to narrow these TypeVars to a single type.
                         const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(declaredReturnType);
-                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => typeVar.shared.constraints.length > 0)) {
-                            const typeVarContext = new typeVarContext_1.TypeVarContext();
+                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => types_1.TypeVarType.hasConstraints(typeVar))) {
+                            const constraints = new constraintTracker_1.ConstraintTracker();
                             for (const typeVar of uniqueTypeVars) {
-                                if (typeVar.shared.constraints.length > 0) {
-                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, typeVar);
+                                if (types_1.TypeVarType.hasConstraints(typeVar)) {
+                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, types_1.TypeVarType.cloneAsBound(typeVar));
                                     if (narrowedType) {
-                                        (0, typeUtils_1.setTypeVarType)(typeVarContext, typeVar, narrowedType);
-                                        typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(typeVar));
+                                        constraints.setBounds(typeVar, narrowedType);
                                     }
                                 }
                             }
-                            if (!typeVarContext.isEmpty()) {
-                                let adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
-                                adjustedReturnType = this._evaluator.stripTypeGuard(adjustedReturnType);
-                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum)) {
+                            if (!constraints.isEmpty()) {
+                                adjReturnType = this._evaluator.solveAndApplyConstraints(declaredReturnType, constraints);
+                                adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(adjReturnType, liveScopes);
+                                if (this._evaluator.assignType(adjReturnType, returnType, diagAddendum)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -763,7 +764,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitAugmentedAssignment(node) {
-        this._evaluator.evaluateTypesForStatement(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.destExpr, typeResult);
         return true;
     }
     visitIndex(node) {
@@ -832,7 +834,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateContainmentTypes(node);
             }
         }
-        this._evaluator.getType(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.leftExpr, typeResult);
         return true;
     }
     visitSlice(node) {
@@ -851,7 +854,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.d.operator === 38 /* OperatorType.Not */) {
             this._validateConditionalIsBool(node.d.expr);
         }
-        this._evaluator.getType(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.expr, typeResult);
         return true;
     }
     visitTernary(node) {
@@ -1164,6 +1168,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isTypeBool = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
         this._evaluator.mapSubtypesExpandTypeVars(operandType, /* options */ undefined, (expandedSubtype) => {
+            var _a;
             if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
                 return undefined;
             }
@@ -1172,8 +1177,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return undefined;
             }
             // Invoke the __bool__ method on the type.
-            const boolReturnType = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
-            /* inferenceContext */ undefined);
+            const boolReturnType = (_a = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
+            /* inferenceContext */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
             if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
                 return undefined;
             }
@@ -1406,6 +1411,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         isPossiblyTrue = true;
                     }
                 });
+                (0, typeUtils_1.doForEachSubtype)(rightType, (rightSubtype) => {
+                    if (this._evaluator.assignType(leftType, rightSubtype)) {
+                        isPossiblyTrue = true;
+                    }
+                });
                 if (!isPossiblyTrue) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                         leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
@@ -1582,13 +1592,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             var _a, _b, _c, _d, _e, _f, _g;
             const nameType = this._evaluator.getType(nameNode);
             ``;
-            if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.shared.isSynthesizedSelf) {
+            if (nameType && (0, types_1.isTypeVar)(nameType) && !types_1.TypeVarType.isSelf(nameType)) {
                 // Does this name refer to a TypeVar that is scoped to this function?
                 if (nameType.priv.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
                     // We exempt constrained TypeVars, TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
-                    let isExempt = nameType.shared.constraints.length > 0 ||
+                    let isExempt = types_1.TypeVarType.hasConstraints(nameType) ||
                         nameType.shared.isDefaultExplicit ||
                         (exemptBoundTypeVar && subscriptIndex !== undefined) ||
                         (0, types_1.isParamSpec)(nameType);
@@ -1802,8 +1812,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
-                    /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    /* diag */ undefined, 
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
                         name: node.d.name.d.value,
@@ -1834,6 +1845,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return undefined;
     }
     _isOverlappingOverload(functionType, prevOverload, partialOverlap) {
+        var _a, _b, _c;
         // According to precedent, the __get__ method is special-cased and is
         // exempt from overlapping overload checks. It's not clear why this is
         // the case, but for consistency with other type checkers, we'll honor
@@ -1846,24 +1858,49 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (partialOverlap) {
             flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
+        const functionNode = (_a = functionType.shared.declaration) === null || _a === void 0 ? void 0 : _a.node;
+        if (functionNode) {
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(functionNode);
+            functionType = (0, typeUtils_1.makeTypeVarsBound)(functionType, liveTypeVars);
+        }
+        // Use the parent node of the declaration in this case so we don't transform
+        // function-local type variables into bound type variables.
+        const prevOverloadNode = (_c = (_b = prevOverload.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent;
+        if (prevOverloadNode) {
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(prevOverloadNode);
+            prevOverload = (0, typeUtils_1.makeTypeVarsBound)(prevOverload, liveTypeVars);
+        }
         return this._evaluator.assignType(functionType, prevOverload, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-        /* srcTypeVarContext */ undefined, flags);
-    }
-    _isLegalOverloadImplementation(overload, implementation, diag) {
-        var _a;
-        const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
-        const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+        /* diag */ undefined, 
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ undefined, flags);
+    }
+    // Determines whether the implementation of an overload is compatible with an
+    // overload signature. To be compatible, the implementation must accept all
+    // of the same arguments as the overload and return a type that is consistent
+    // with the overload's return type.
+    _validateOverloadImplementation(overload, implementation, diag) {
+        var _a, _b, _c;
+        const implConstraints = new constraintTracker_1.ConstraintTracker();
+        const overloadConstraints = new constraintTracker_1.ConstraintTracker();
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadConstraints, implConstraints, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
             512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
-        const overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
-        const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
+        let overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
+        let implementationReturnType = this._evaluator.solveAndApplyConstraints(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implConstraints);
+        if ((_c = (_b = implementation.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent) {
+            // Use the parent node of the implementation to determine which type variables
+            // are live. This will include any class-scoped type variables if this is an
+            // overloaded method.
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implementation.shared.declaration.node.parent);
+            implementationReturnType = (0, typeUtils_1.makeTypeVarsBound)(implementationReturnType, liveScopeIds);
+            overloadReturnType = (0, typeUtils_1.makeTypeVarsBound)(overloadReturnType, liveScopeIds);
+        }
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
-            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implConstraints, overloadConstraints, 0 /* AssignTypeFlags.Default */)) {
             returnDiag.addMessage(localize_1.LocAddendum.functionReturnTypeMismatch().format({
                 sourceType: this._evaluator.printType(overloadReturnType),
                 destType: this._evaluator.printType(implementationReturnType),
@@ -2156,7 +2193,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
             var _a, _b, _c, _d;
             const diag = new diagnostic_1.DiagnosticAddendum();
-            if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
+            if (!this._validateOverloadImplementation(overload, implementationFunction, diag)) {
                 if (implementationFunction.shared.declaration) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
                         name,
@@ -2994,6 +3031,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._reportDeprecatedDiagnostic(node, errorMessage, info.deprecatedMessage);
         }
     }
+    _reportDeprecatedUseForOperation(node, typeResult) {
+        const deprecationInfo = typeResult === null || typeResult === void 0 ? void 0 : typeResult.magicMethodDeprecationInfo;
+        if (!deprecationInfo) {
+            return;
+        }
+        this._reportDeprecatedDiagnostic(node, localize_1.LocMessage.deprecatedMethod().format({
+            className: deprecationInfo.className,
+            name: deprecationInfo.methodName,
+        }), deprecationInfo.deprecatedMessage);
+    }
     _reportDeprecatedUseForType(node, type, isImportFromTyping = false) {
         var _a, _b, _c;
         if (!type) {
@@ -3042,7 +3089,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = getDeprecatedMessageForFunction(overload);
                         }
-                        else if ((0, types_1.isInstantiableClass)(type) && overload.shared.name === '__init__') {
+                        else if ((0, types_1.isInstantiableClass)(type) &&
+                            ['__init__', '__new__'].includes(overload.shared.name)) {
                             deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = localize_1.LocMessage.deprecatedConstructor().format({
                                 name: type.shared.name,
@@ -3390,13 +3438,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.d.name);
         }
         if (isTypeIs) {
-            const typeGuardType = returnType.priv.typeArgs[0];
+            const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(functionType);
+            const typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(returnType.priv.typeArgs[0], scopeIds);
             // Determine the type of the first parameter.
             const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
             if (paramIndex >= functionType.shared.parameters.length) {
                 return;
             }
-            const paramType = types_1.FunctionType.getEffectiveParamType(functionType, paramIndex);
+            const paramType = (0, typeUtils_1.makeTypeVarsBound)(types_1.FunctionType.getParamType(functionType, paramIndex), scopeIds);
             // Verify that the typeGuardType is a narrower type than the paramType.
             if (!this._evaluator.assignType(paramType, typeGuardType)) {
                 const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
@@ -3446,6 +3495,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (declaredReturnType) {
                 this._reportUnknownReturnResult(node, declaredReturnType);
                 this._validateReturnTypeIsNotContravariant(declaredReturnType, returnAnnotation);
+                const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
             }
             // Wrap the declared type in a generator type if the function is a generator.
             if (types_1.FunctionType.isGenerator(functionType)) {
@@ -3623,13 +3674,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     ];
                     if (newMemberTypeResult) {
                         this._evaluator.validateCallArgs(errorNode, argList, newMemberTypeResult, 
-                        /* typeVarContext */ undefined, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
                         /* inferenceContext */ undefined);
                     }
                     if (initMemberTypeResult) {
                         this._evaluator.validateCallArgs(errorNode, argList, initMemberTypeResult, 
-                        /* typeVarContext */ undefined, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
                         /* inferenceContext */ undefined);
                     }
@@ -3688,7 +3739,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Verify that the parameter count matches.
-        const nonDefaultParams = paramListDetails.params.filter((paramInfo) => !paramInfo.param.defaultType);
+        const nonDefaultParams = paramListDetails.params.filter((paramInfo, index) => types_1.FunctionType.getParamDefaultType(postInitType, index) === undefined);
         // We expect to see one param for "self" plus one for each of the InitVars.
         const expectedParamCount = initOnlySymbolMap.size + 1;
         const postInitNode = postInitType.shared.declaration.node;
@@ -3707,7 +3758,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const annotationNode = (_a = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _a !== void 0 ? _a : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
             if (types_1.FunctionParam.isTypeDeclared(param) && annotationNode) {
                 const fieldType = (_b = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
-                const paramType = types_1.FunctionType.getEffectiveParamType(postInitType, paramListDetails.params[paramIndex].index);
+                const paramType = types_1.FunctionType.getParamType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), annotationNode);
@@ -3890,7 +3941,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
         classType.shared.typeParams.forEach((param, paramIndex) => {
-            // Skip variadics and ParamSpecs.
+            // Skip TypeVarTuples and ParamSpecs.
             if ((0, types_1.isTypeVarTuple)(param) || (0, types_1.isParamSpec)(param)) {
                 return;
             }
@@ -4035,12 +4086,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.shared.declaration;
             const newDecl = newMemberType.shared.declaration;
@@ -4087,16 +4138,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         for (const baseClass of filteredBaseClasses) {
-            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClass);
             for (const baseClassMroClass of baseClass.shared.mro) {
                 // There's no need to check for conflicts if this class isn't generic.
                 if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.shared.typeParams.length > 0) {
-                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
+                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, solution);
                     // Find the corresponding class in the derived class's MRO list.
                     const matchingMroClass = classType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, specializedBaseClassMroClass));
                     if (matchingMroClass && (0, types_1.isInstantiableClass)(matchingMroClass)) {
-                        const matchingMroObject = types_1.ClassType.cloneAsInstance(matchingMroClass);
-                        const baseClassMroObject = types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass);
+                        const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(classType);
+                        const matchingMroObject = (0, typeUtils_1.makeTypeVarsBound)(types_1.ClassType.cloneAsInstance(matchingMroClass), scopeIds);
+                        const baseClassMroObject = (0, typeUtils_1.makeTypeVarsBound)(types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass), scopeIds);
                         if (!this._evaluator.assignType(matchingMroObject, baseClassMroObject)) {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             const baseClassObject = (0, typeUtils_1.convertToInstance)(baseClass);
@@ -4281,8 +4333,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                     diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
                         classType: childClassType.shared.name,
                         name: memberName,
@@ -4448,9 +4500,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             const baseTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, baseClass, 
             /* allowNarrowed */ false);
-            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClass);
             const baseExtraItemsType = baseTypedDictEntries.extraItems
-                ? (0, typeUtils_1.applySolvedTypeVars)(baseTypedDictEntries.extraItems.valueType, typeVarContext)
+                ? (0, typeUtils_1.applySolvedTypeVars)(baseTypedDictEntries.extraItems.valueType, solution)
                 : types_1.UnknownType.create();
             for (const [name, entry] of typedDictEntries.knownItems) {
                 const baseEntry = baseTypedDictEntries.knownItems.get(name);
@@ -4462,8 +4514,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     else if (!this._evaluator.assignType(baseExtraItemsType, entry.valueType, 
                     /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
                         ? 1 /* AssignTypeFlags.EnforceInvariance */
                         : 0 /* AssignTypeFlags.Default */)) {
                         diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
@@ -4481,8 +4533,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (typedDictEntries.extraItems && baseTypedDictEntries.extraItems) {
                 if (!this._evaluator.assignType(baseExtraItemsType, typedDictEntries.extraItems.valueType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
                     ? 1 /* AssignTypeFlags.EnforceInvariance */
                     : 0 /* AssignTypeFlags.Default */)) {
                     diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
@@ -4794,8 +4846,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                         if (isInvariant) {
                             diagAddendum = new diagnostic_1.DiagnosticAddendum();
                             diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
@@ -5111,6 +5163,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // If there is no type annotation, there's nothing to check because
         // the type will be inferred.d.typeAnnotation
         const paramInfo = functionType.shared.parameters[0];
+        const paramType = types_1.FunctionType.getParamType(functionType, 0);
         const paramAnnotation = (_a = node.d.params[0].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[0].d.annotationComment;
         if (!paramAnnotation || !paramInfo.name) {
             return;
@@ -5119,11 +5172,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // use of class-scoped TypeVars, which are not allowed in this context
         // according to the typing spec.
         if (functionType.shared.name === '__init__' && functionType.shared.methodClass) {
-            const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(paramInfo.type);
+            const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(paramType);
             if (typeVars.some((typeVar) => {
                 var _a;
                 return typeVar.priv.scopeId === ((_a = functionType.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId) &&
-                    !typeVar.shared.isSynthesizedSelf;
+                    !types_1.TypeVarType.isSelf(typeVar);
             })) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramAnnotation);
             }
@@ -5133,20 +5186,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.ClassType.isProtocolClass(classType)) {
             return;
         }
-        const paramType = this._evaluator.makeTopLevelTypeVarsConcrete(paramInfo.type);
+        const concreteParamType = this._evaluator.makeTopLevelTypeVarsConcrete(paramType);
         const expectedType = isCls ? classType : (0, typeUtils_1.convertToInstance)(classType);
         // If the declared type is a protocol class or instance, skip
         // the check. This has legitimate uses for mix-in classes.
-        if ((0, types_1.isInstantiableClass)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+        if ((0, types_1.isInstantiableClass)(concreteParamType) && types_1.ClassType.isProtocolClass(concreteParamType)) {
             return;
         }
-        if ((0, types_1.isClassInstance)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+        if ((0, types_1.isClassInstance)(concreteParamType) && types_1.ClassType.isProtocolClass(concreteParamType)) {
             return;
         }
         // If the method starts with a `*args: P.args`, skip the check.
         if (paramInfo.category === 1 /* ParamCategory.ArgsList */ &&
-            (0, types_1.isParamSpec)(paramInfo.type) &&
-            paramInfo.type.priv.paramSpecAccess === 'args') {
+            (0, types_1.isParamSpec)(paramType) &&
+            paramType.priv.paramSpecAccess === 'args') {
             return;
         }
         // Don't enforce this for an overloaded method because the "self" param
@@ -5163,8 +5216,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             types_1.ClassType.isBuiltIn(classType, 'str')) {
             return;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType));
-        if (!this._evaluator.assignType(paramType, expectedType, /* diag */ undefined, typeVarContext)) {
+        if (!this._evaluator.assignType(paramType, expectedType)) {
             // We exempt Never from this check because it has a legitimate use in this case.
             if (!(0, types_1.isNever)(paramType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.clsSelfParamTypeMismatch().format({
@@ -5191,7 +5243,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
+        declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
         let generatorType;
         if (!enclosingFunctionNode.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&