@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/dist/analyzer/checker.js

@@ -50,13 +50,13 @@ const importStatementUtils_1 = require("./importStatementUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const parseTreeWalker_1 = require("./parseTreeWalker");
 const patternMatching_1 = require("./patternMatching");
-const protocols_1 = require("./protocols");
 const scopeUtils_1 = require("./scopeUtils");
 const sourceMapper_1 = require("./sourceMapper");
 const staticExpressions_1 = require("./staticExpressions");
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
 const typeEvaluator_1 = require("./typeEvaluator");
+const typeGuards_1 = require("./typeGuards");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
@@ -110,6 +110,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // A list of all nodes that are defined within the module that
         // have their own scopes.
         this._scopedNodes = [];
+        // A list of all visited type parameter lists.
+        this._typeParameterLists = [];
         this._fileInfo = AnalyzerNodeInfo.getFileInfo(_moduleNode);
     }
     check() {
@@ -155,6 +157,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitClass(node) {
         const classTypeResult = this._evaluator.getTypeOfClass(node);
+        if (node.typeParameters) {
+            this.walk(node.typeParameters);
+        }
         this.walk(node.suite);
         this.walkMultiple(node.decorators);
         this.walkMultiple(node.arguments);
@@ -210,6 +215,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitFunction(node) {
         var _a;
+        if (node.typeParameters) {
+            this.walk(node.typeParameters);
+        }
         const functionTypeResult = this._evaluator.getTypeOfFunction(node);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         if (functionTypeResult) {
@@ -319,7 +327,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (annotationNode && index < functionTypeResult.functionType.details.parameters.length) {
                     const paramType = functionTypeResult.functionType.details.parameters[index].type;
                     if ((0, types_1.isTypeVar)(paramType) &&
-                        paramType.details.variance === 1 /* Covariant */ &&
+                        paramType.details.declaredVariance === 2 /* Covariant */ &&
                         !paramType.details.isSynthesized &&
                         functionTypeResult.functionType.details.name !== '__init__') {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramTypeCovariant(), annotationNode);
@@ -459,6 +467,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitFor(node) {
         this._evaluator.evaluateTypesForStatement(node);
+        if (node.typeComment) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.annotationNotSupported(), node.typeComment);
+        }
         return true;
     }
     visitList(node) {
@@ -495,6 +506,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         node.withItems.forEach((item) => {
             this._evaluator.evaluateTypesForStatement(item);
         });
+        if (node.typeComment) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.annotationNotSupported(), node.typeComment);
+        }
         return true;
     }
     visitReturn(node) {
@@ -847,6 +861,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
+    visitTypeParameterList(node) {
+        this._typeParameterLists.push(node);
+        return true;
+    }
+    visitTypeParameter(node) {
+        return false;
+    }
     visitTypeAnnotation(node) {
         this._evaluator.getType(node.typeAnnotation);
         return true;
@@ -1306,7 +1327,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return undefined;
         }
         for (const decl of decls) {
-            if (decl.type === 3 /* Function */) {
+            if (decl.type === 5 /* Function */) {
                 const functionType = this._evaluator.getTypeOfFunction(decl.node);
                 if ((functionType === null || functionType === void 0 ? void 0 : functionType.functionType) === overloadType) {
                     return decl.node;
@@ -1535,12 +1556,26 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 });
             }
         }
+        // Report unaccessed type parameters.
+        const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
+        for (const paramList of this._typeParameterLists) {
+            for (const param of paramList.parameters) {
+                const symbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
+                (0, debug_1.assert)(symbol);
+                if (!accessedSymbolSet.has(symbol.id)) {
+                    const decls = symbol.getDeclarations();
+                    decls.forEach((decl) => {
+                        this._conditionallyReportUnusedDeclaration(decl, /* isPrivate */ false);
+                    });
+                }
+            }
+        }
     }
     _reportInvalidOverload(name, symbol) {
         const typedDecls = symbol.getTypedDeclarations();
         if (typedDecls.length >= 1) {
             const primaryDecl = typedDecls[0];
-            if (primaryDecl.type === 3 /* Function */) {
+            if (primaryDecl.type === 5 /* Function */) {
                 const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
                 const functions = (0, types_1.isOverloadedFunction)(type) ? type.overloads : (0, types_1.isFunction)(type) ? [type] : [];
                 const overloadedFunctions = functions.filter((func) => types_1.FunctionType.isOverloaded(func));
@@ -1690,10 +1725,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let otherDecls = symbol.getDeclarations().filter((decl) => decl !== primaryDecl);
         // If it's a function, we can skip any other declarations
         // that are overloads or property setters/deleters.
-        if (primaryDecl.type === 3 /* Function */) {
+        if (primaryDecl.type === 5 /* Function */) {
             const primaryDeclTypeInfo = this._evaluator.getTypeOfFunction(primaryDecl.node);
             otherDecls = otherDecls.filter((decl) => {
-                if (decl.type !== 3 /* Function */) {
+                if (decl.type !== 5 /* Function */) {
                     return true;
                 }
                 const funcTypeInfo = this._evaluator.getTypeOfFunction(decl.node);
@@ -1721,7 +1756,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let primaryDeclInfo;
-        if (primaryDecl.type === 3 /* Function */) {
+        if (primaryDecl.type === 5 /* Function */) {
             if (primaryDecl.isMethod) {
                 primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeMethodDeclaration();
             }
@@ -1729,7 +1764,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeFunctionDeclaration();
             }
         }
-        else if (primaryDecl.type === 4 /* Class */) {
+        else if (primaryDecl.type === 6 /* Class */) {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeClassDeclaration();
         }
         else if (primaryDecl.type === 2 /* Parameter */) {
@@ -1738,13 +1773,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         else if (primaryDecl.type === 1 /* Variable */) {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeVariableDeclaration();
         }
+        else if (primaryDecl.type === 4 /* TypeAlias */) {
+            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeTypeAliasDeclaration();
+        }
         else {
             primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeDeclaration();
         }
         const addPrimaryDeclInfo = (diag) => {
             if (diag) {
                 let primaryDeclNode;
-                if (primaryDecl.type === 3 /* Function */ || primaryDecl.type === 4 /* Class */) {
+                if (primaryDecl.type === 5 /* Function */ || primaryDecl.type === 6 /* Class */) {
                     primaryDeclNode = primaryDecl.node.name;
                 }
                 else if (primaryDecl.type === 1 /* Variable */) {
@@ -1752,7 +1790,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         primaryDeclNode = primaryDecl.node;
                     }
                 }
-                else if (primaryDecl.type === 2 /* Parameter */) {
+                else if (primaryDecl.type === 2 /* Parameter */ ||
+                    primaryDecl.type === 3 /* TypeParameter */) {
                     if (primaryDecl.node.name) {
                         primaryDeclNode = primaryDecl.node.name;
                     }
@@ -1763,20 +1802,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         };
         for (const otherDecl of otherDecls) {
-            if (otherDecl.type === 4 /* Class */) {
-                const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
-                addPrimaryDeclInfo(diag);
+            if (otherDecl.type === 6 /* Class */) {
+                let duplicateIsOk = false;
+                if (primaryDecl.type === 3 /* TypeParameter */) {
+                    // The error will be reported elsewhere if a type parameter is
+                    // involved, so don't report it here.
+                    duplicateIsOk = true;
+                }
+                if (!duplicateIsOk) {
+                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
+                    addPrimaryDeclInfo(diag);
+                }
             }
-            else if (otherDecl.type === 3 /* Function */) {
+            else if (otherDecl.type === 5 /* Function */) {
                 const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl);
+                let duplicateIsOk = false;
                 // If the return type has not yet been inferred, do so now.
                 if (primaryType && (0, types_1.isFunction)(primaryType)) {
                     this._evaluator.getFunctionInferredReturnType(primaryType);
                 }
-                let duplicateIsOk = false;
                 const otherType = this._evaluator.getTypeForDeclaration(otherDecl);
                 const suite1 = ParseTreeUtils.getEnclosingSuite(primaryDecl.node);
                 const suite2 = ParseTreeUtils.getEnclosingSuite(otherDecl.node);
+                // Allow same-signature overrides in cases where the declarations
+                // are not within the same statement suite (e.g. one in the "if"
+                // and another in the "else").
                 const isInSameStatementList = suite1 === suite2;
                 // If the return type has not yet been inferred, do so now.
                 if (otherType && (0, types_1.isFunction)(otherType)) {
@@ -1784,10 +1834,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // If both declarations are functions, it's OK if they
                 // both have the same signatures.
-                if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
+                if (!isInSameStatementList && primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                     duplicateIsOk = true;
                 }
-                if (!duplicateIsOk || isInSameStatementList) {
+                if (primaryDecl.type === 3 /* TypeParameter */) {
+                    // The error will be reported elsewhere if a type parameter is
+                    // involved, so don't report it here.
+                    duplicateIsOk = true;
+                }
+                if (!duplicateIsOk) {
                     const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, otherDecl.isMethod
                         ? localize_1.Localizer.Diagnostic.obscuredMethodDeclaration().format({ name })
                         : localize_1.Localizer.Diagnostic.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
@@ -1796,8 +1851,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if (otherDecl.type === 2 /* Parameter */) {
                 if (otherDecl.node.name) {
-                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredParameterDeclaration().format({ name }), otherDecl.node.name);
-                    addPrimaryDeclInfo(diag);
+                    let duplicateIsOk = false;
+                    if (primaryDecl.type === 3 /* TypeParameter */) {
+                        // The error will be reported elsewhere if a type parameter is
+                        // involved, so don't report it here.
+                        duplicateIsOk = true;
+                    }
+                    if (!duplicateIsOk) {
+                        const message = localize_1.Localizer.Diagnostic.obscuredParameterDeclaration();
+                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name }), otherDecl.node.name);
+                        addPrimaryDeclInfo(diag);
+                    }
                 }
             }
             else if (otherDecl.type === 1 /* Variable */) {
@@ -1810,24 +1874,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                             duplicateIsOk = true;
                         }
+                        if (primaryDecl.type === 3 /* TypeParameter */) {
+                            // The error will be reported elsewhere if a type parameter is
+                            // involved, so don't report it here.
+                            duplicateIsOk = true;
+                        }
                         if (!duplicateIsOk) {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredVariableDeclaration().format({ name }), otherDecl.node);
                             addPrimaryDeclInfo(diag);
                         }
                     }
                 }
-                else if (primaryType && !(0, typeUtils_1.isProperty)(primaryType)) {
-                    if (primaryDecl.type === 3 /* Function */ || primaryDecl.type === 4 /* Class */) {
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredVariableDeclaration().format({ name }), otherDecl.node);
-                        addPrimaryDeclInfo(diag);
-                    }
-                }
+            }
+            else if (otherDecl.type === 4 /* TypeAlias */) {
+                const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
+                addPrimaryDeclInfo(diag);
             }
         }
     }
     _conditionallyReportUnusedSymbol(name, symbol, scopeType) {
-        const accessedSymbolMap = this._fileInfo.accessedSymbolMap;
-        if (symbol.isIgnoredForProtocolMatch() || accessedSymbolMap.has(symbol.id)) {
+        const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
+        if (symbol.isIgnoredForProtocolMatch() || accessedSymbolSet.has(symbol.id)) {
             return;
         }
         // A name of "_" means "I know this symbol isn't used", so
@@ -1849,7 +1916,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let message;
         let rule;
         switch (decl.type) {
-            case 6 /* Alias */:
+            case 8 /* Alias */:
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedImport;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
                 if (decl.node.nodeType === 21 /* ImportAs */) {
@@ -1888,6 +1955,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     message = localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: nameNode.value });
                 }
                 break;
+            case 4 /* TypeAlias */:
             case 1 /* Variable */:
             case 2 /* Parameter */:
                 if (!isPrivate) {
@@ -1909,7 +1977,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else if (decl.node.nodeType === 41 /* Parameter */) {
                     nameNode = decl.node.name;
-                    // Don't emit a diagnostic for unused parameters.
+                    // Don't emit a diagnostic for unused parameters or type parameters.
                     diagnosticLevel = 'none';
                 }
                 if (nameNode) {
@@ -1917,7 +1985,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     message = localize_1.Localizer.Diagnostic.unaccessedVariable().format({ name: nameNode.value });
                 }
                 break;
-            case 4 /* Class */:
+            case 6 /* Class */:
                 if (!isPrivate) {
                     return;
                 }
@@ -1931,7 +1999,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedClass;
                 message = localize_1.Localizer.Diagnostic.unaccessedClass().format({ name: nameNode.value });
                 break;
-            case 3 /* Function */:
+            case 5 /* Function */:
                 if (!isPrivate) {
                     return;
                 }
@@ -1945,13 +2013,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
                 message = localize_1.Localizer.Diagnostic.unaccessedFunction().format({ name: nameNode.value });
                 break;
-            default:
+            case 3 /* TypeParameter */:
+                // Never report a diagnostic for an unused TypeParameter.
+                diagnosticLevel = 'none';
+                nameNode = decl.node.name;
+                break;
+            case 0 /* Intrinsic */:
+            case 7 /* SpecialBuiltInClass */:
                 return;
+            default:
+                (0, debug_1.assertNever)(decl);
         }
-        if (nameNode && rule !== undefined && message) {
-            const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* unusedImport */ } : undefined;
+        const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* unusedImport */ } : undefined;
+        if (nameNode) {
             this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: nameNode.value }), nameNode, action);
-            this._evaluator.addDiagnostic(diagnosticLevel, rule, message, nameNode);
+            if (rule !== undefined && message) {
+                this._evaluator.addDiagnostic(diagnosticLevel, rule, message, nameNode);
+            }
         }
     }
     // Validates that a call to isinstance or issubclass are necessary. This is a
@@ -2087,18 +2165,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const filterType = (varType) => {
             const filteredTypes = [];
             for (const filterType of classTypeList) {
-                // Handle the special case where the variable type is a TypedDict and
-                // we're filtering against 'dict'. TypedDict isn't derived from dict,
-                // but at runtime, isinstance returns True.
-                const filterIsSuperclass = types_1.ClassType.isDerivedFrom(varType, filterType) ||
-                    (isInstanceCheck &&
-                        types_1.ClassType.isProtocolClass(filterType) &&
-                        this._evaluator.assignType(filterType, varType)) ||
-                    (types_1.ClassType.isBuiltIn(filterType, 'dict') && types_1.ClassType.isTypedDictClass(varType));
-                const filterIsSubclass = types_1.ClassType.isDerivedFrom(filterType, varType) ||
-                    (isInstanceCheck &&
-                        types_1.ClassType.isProtocolClass(varType) &&
-                        this._evaluator.assignType(varType, filterType));
+                const filterIsSuperclass = (0, typeGuards_1.isIsinstanceFilterSuperclass)(this._evaluator, varType, filterType, filterType, isInstanceCheck);
+                const filterIsSubclass = (0, typeGuards_1.isIsinstanceFilterSubclass)(this._evaluator, varType, filterType, filterType, isInstanceCheck);
                 // Normally, a class should never be both a subclass and a
                 // superclass. However, this can happen if one of the classes
                 // derives from an unknown type. In this case, we'll add an
@@ -2294,7 +2362,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!primaryDeclaration || primaryDeclaration.node === node) {
             return;
         }
-        if (primaryDeclaration.type === 6 /* Alias */) {
+        if (primaryDeclaration.type === 8 /* Alias */) {
             // If this symbol is an import alias (i.e. it's a local name rather than the
             // original imported name), skip the private check.
             if (primaryDeclaration.usesLocalName) {
@@ -2480,7 +2548,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }), returnAnnotation);
                 }
                 const diag = new diagnostic_1.DiagnosticAddendum();
-                if ((0, types_1.isTypeVar)(declaredReturnType) && declaredReturnType.details.variance === 2 /* Contravariant */) {
+                if ((0, types_1.isTypeVar)(declaredReturnType) &&
+                    declaredReturnType.details.declaredVariance === 3 /* Contravariant */) {
                     diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarIsContravariant().format({
                         name: types_1.TypeVarType.getReadableName(declaredReturnType),
                     }));
@@ -2610,7 +2679,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                else if (decls[0].type === 3 /* Function */) {
+                else if (decls[0].type === 5 /* Function */) {
                     if (ParseTreeUtils.isSuiteEmpty(decls[0].node.suite) && decls[0]) {
                         if ((0, pathUtils_1.getFileExtension)(decls[0].path).toLowerCase() !== '.pyi') {
                             if (!isSymbolImplemented(name)) {
@@ -2645,8 +2714,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Collect the list of init-only variables in the order they were declared.
         const initOnlySymbolMap = new Map();
-        for (let i = classType.details.mro.length - 1; i >= 0; i--) {
-            const mroClass = classType.details.mro[i];
+        types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
             if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isDataClass(mroClass)) {
                 mroClass.details.fields.forEach((symbol, name) => {
                     if (symbol.isInitVar()) {
@@ -2654,7 +2722,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 });
             }
-        }
+        });
         const postInitType = this._evaluator.getTypeOfMember(postInitMember);
         if (!(0, types_1.isFunction)(postInitType) ||
             !types_1.FunctionType.isInstanceMethod(postInitType) ||
@@ -2800,9 +2868,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // the proper variance (invariant, covariant, contravariant). See PEP 544
     // for an explanation for why this is important to enforce.
     _validateProtocolTypeParamVariance(errorNode, classType) {
-        const origTypeParams = classType.details.typeParameters.filter((typeParam) => !(0, types_1.isParamSpec)(typeParam));
-        // If this isn't a generic protocol, there's nothing to do here.
-        if (origTypeParams.length === 0) {
+        // If this protocol has no TypeVars with specified variance, there's nothing to do here.
+        if (classType.details.typeParameters.length === 0) {
             return;
         }
         const objectType = this._evaluator.getBuiltInType(errorNode, 'object');
@@ -2810,13 +2877,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Replace all of the type parameters with invariant TypeVars.
-        const updatedTypeParams = origTypeParams.map((typeParam) => (0, types_1.isVariadicTypeVar)(typeParam) ? typeParam : types_1.TypeVarType.cloneAsInvariant(typeParam));
+        const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
         const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
-        const dummyTypeObject = types_1.ClassType.createInstantiable('__protocolVarianceDummy', '', '', '', 0, 0, undefined, undefined);
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', '', 0, 0, undefined, undefined);
         updatedTypeParams.forEach((param, paramIndex) => {
-            // Skip variadics.
-            if (param.details.isVariadic) {
+            // Skip variadics and ParamSpecs.
+            if (param.details.isVariadic || param.details.isParamSpec) {
+                return;
+            }
+            // Skip type variables with auto-variance.
+            if (param.details.declaredVariance === 0 /* Auto */) {
                 return;
             }
             // Replace all type arguments with a dummy type except for the
@@ -2836,29 +2907,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             /* isTypeArgumentExplicit */ true);
             const destType = types_1.ClassType.cloneForSpecialization(updatedClassType, destTypeArgs, 
             /* isTypeArgumentExplicit */ true);
-            const isDestSubtypeOfSrc = (0, protocols_1.assignProtocolClassToSelf)(this._evaluator, srcType, destType);
+            const isDestSubtypeOfSrc = this._evaluator.assignClassToSelf(srcType, destType);
             let expectedVariance;
             if (isDestSubtypeOfSrc) {
-                expectedVariance = 1 /* Covariant */;
+                expectedVariance = 2 /* Covariant */;
             }
             else {
-                const isSrcSubtypeOfDest = (0, protocols_1.assignProtocolClassToSelf)(this._evaluator, destType, srcType);
+                const isSrcSubtypeOfDest = this._evaluator.assignClassToSelf(destType, srcType);
                 if (isSrcSubtypeOfDest) {
-                    expectedVariance = 2 /* Contravariant */;
+                    expectedVariance = 3 /* Contravariant */;
                 }
                 else {
-                    expectedVariance = 0 /* Invariant */;
+                    expectedVariance = 1 /* Invariant */;
                 }
             }
-            if (expectedVariance !== origTypeParams[paramIndex].details.variance) {
+            if (expectedVariance !== classType.details.typeParameters[paramIndex].details.declaredVariance) {
                 let message;
-                if (expectedVariance === 1 /* Covariant */) {
+                if (expectedVariance === 2 /* Covariant */) {
                     message = localize_1.Localizer.Diagnostic.protocolVarianceCovariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
                     });
                 }
-                else if (expectedVariance === 2 /* Contravariant */) {
+                else if (expectedVariance === 3 /* Contravariant */) {
                     message = localize_1.Localizer.Diagnostic.protocolVarianceContravariant().format({
                         variable: param.details.name,
                         class: classType.details.name,
@@ -3101,7 +3172,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!this._evaluator.validateOverrideMethod(baseType, overrideFunction, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
                     const decl = overrideFunction.details.declaration;
-                    if (decl && decl.type === 3 /* Function */) {
+                    if (decl && decl.type === 5 /* Function */) {
                         diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.baseClassMethodTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
@@ -3230,7 +3301,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
                                 name: memberName,
                                 className: baseClassAndSymbol.classType.details.name,
-                            }) + diagAddendum.getString(), decl.type === 3 /* Function */ ? decl.node.name : decl.node);
+                            }) + diagAddendum.getString(), decl.type === 5 /* Function */ ? decl.node.name : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
                                 diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
@@ -3242,7 +3313,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // Private names (starting with double underscore) are exempt from this check.
                     if (!SymbolNameUtils.isPrivateName(memberName) && types_1.FunctionType.isFinal(baseType)) {
                         const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
-                        if (decl && decl.type === 3 /* Function */) {
+                        if (decl && decl.type === 5 /* Function */) {
                             const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
                                 name: memberName,
                                 className: baseClassAndSymbol.classType.details.name,
@@ -3324,7 +3395,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                             name: methodName,
                                         }));
                                         const decl = subclassMethodType.details.declaration;
-                                        if (decl && decl.type === 3 /* Function */) {
+                                        if (decl && decl.type === 5 /* Function */) {
                                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                                                 name: memberName,
                                                 className: baseClassType.details.name,
@@ -3375,7 +3446,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         // If the subclass is declaring an inner class, we'll consider that
                         // to be a ClassVar.
-                        if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 4 /* Class */)) {
+                        if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 6 /* Class */)) {
                             isClassVar = true;
                         }
                     }