@zzzen/pyright-internal 1.2.0-dev.20230813 → 1.2.0-dev.20230827

package/dist/analyzer/checker.js

@@ -47,6 +47,8 @@ const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const declaration_1 = require("./declaration");
+const declarationUtils_1 = require("./declarationUtils");
+const deprecatedSymbols_1 = require("./deprecatedSymbols");
 const importResolver_1 = require("./importResolver");
 const importStatementUtils_1 = require("./importStatementUtils");
 const parameterUtils_1 = require("./parameterUtils");
@@ -65,43 +67,6 @@ const typeGuards_1 = require("./typeGuards");
 const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
 const types_1 = require("./types");
-const deprecatedAliases = new Map([
-    ['Tuple', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.tuple', replacementText: 'tuple' }],
-    ['List', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.list', replacementText: 'list' }],
-    ['Dict', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.dict', replacementText: 'dict' }],
-    ['Set', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.set', replacementText: 'set' }],
-    ['FrozenSet', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.frozenset', replacementText: 'frozenset' }],
-    ['Type', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.type', replacementText: 'type' }],
-    ['Deque', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'collections.deque', replacementText: 'collections.deque' }],
-    [
-        'DefaultDict',
-        {
-            version: pythonVersion_1.PythonVersion.V3_9,
-            fullName: 'collections.defaultdict',
-            replacementText: 'collections.defaultdict',
-        },
-    ],
-    [
-        'OrderedDict',
-        {
-            version: pythonVersion_1.PythonVersion.V3_9,
-            fullName: 'collections.OrderedDict',
-            replacementText: 'collections.OrderedDict',
-        },
-    ],
-    [
-        'Counter',
-        { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'collections.Counter', replacementText: 'collections.Counter' },
-    ],
-    [
-        'ChainMap',
-        { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'collections.ChainMap', replacementText: 'collections.ChainMap' },
-    ],
-]);
-const deprecatedSpecialForms = new Map([
-    ['Optional', { version: pythonVersion_1.PythonVersion.V3_10, fullName: 'typing.Optional', replacementText: '| None' }],
-    ['Union', { version: pythonVersion_1.PythonVersion.V3_10, fullName: 'typing.Union', replacementText: '|' }],
-]);
 // When enabled, this debug flag causes the code complexity of
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
@@ -211,6 +176,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateBaseClassOverrides(classTypeResult.classType);
                 this._validateSlotsClassVarConflict(classTypeResult.classType);
             }
+            this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
             this._validateConstructorConsistency(classTypeResult.classType);
             this._validateFinalMemberOverrides(classTypeResult.classType);
@@ -339,12 +305,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (param.typeAnnotationComment) {
                 this.walk(param.typeAnnotationComment);
             }
+            // Look for method parameters that are typed with TypeVars that have the wrong variance.
             if (functionTypeResult) {
                 const annotationNode = param.typeAnnotation || param.typeAnnotationComment;
                 if (annotationNode && index < functionTypeResult.functionType.details.parameters.length) {
                     const paramType = functionTypeResult.functionType.details.parameters[index].type;
                     const exemptMethods = ['__init__', '__new__'];
-                    if ((0, types_1.isTypeVar)(paramType) &&
+                    if (containingClassNode &&
+                        (0, types_1.isTypeVar)(paramType) &&
                         paramType.details.declaredVariance === 3 /* Covariant */ &&
                         !paramType.details.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.details.name)) {
@@ -629,6 +597,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a, _b, _c, _d;
         const yieldFromType = this._evaluator.getType(node.expression) || types_1.UnknownType.create();
         let yieldType;
+        let sendType;
         if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
             // Handle the case of old-style (pre-await) coroutines.
             yieldType = types_1.UnknownType.create();
@@ -642,13 +611,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldType);
             if (generatorTypeArgs) {
                 yieldType = generatorTypeArgs.length >= 1 ? generatorTypeArgs[0] : types_1.UnknownType.create();
+                sendType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[1] : undefined;
             }
             else {
                 yieldType =
                     (_d = (_c = this._evaluator.getTypeOfIterator({ type: yieldFromType }, /* isAsync */ false, node)) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
             }
         }
-        this._validateYieldType(node, yieldType);
+        this._validateYieldType(node, yieldType, sendType);
         return true;
     }
     visitRaise(node) {
@@ -930,7 +900,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitMemberAccess(node) {
         const type = this._evaluator.getType(node);
-        this._reportDeprecatedUse(node.memberName, type);
+        const leftExprType = this._evaluator.getType(node.leftExpression);
+        this._reportDeprecatedUse(node.memberName, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.moduleName === 'typing');
         this._conditionallyReportPrivateUsage(node.memberName);
         // Walk the leftExpression but not the memberName.
         this.walk(node.leftExpression);
@@ -957,6 +928,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             });
         }
         else {
+            this._evaluator.evaluateTypesForStatement(node);
             const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
             if (importInfo &&
                 importInfo.isImportFound &&
@@ -968,7 +940,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitImportFromAs(node) {
-        var _a;
+        var _a, _b;
         if (this._fileInfo.isStubFile) {
             return false;
         }
@@ -992,8 +964,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node.name);
             break;
         }
-        const type = this._evaluator.getType((_a = node.alias) !== null && _a !== void 0 ? _a : node.name);
-        this._reportDeprecatedUse(node.name, type);
+        let isImportFromTyping = false;
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ImportFrom */) {
+            if (node.parent.module.leadingDots === 0 && node.parent.module.nameParts.length === 1) {
+                if (node.parent.module.nameParts[0].value === 'typing') {
+                    isImportFromTyping = true;
+                }
+            }
+        }
+        const type = this._evaluator.getType((_b = node.alias) !== null && _b !== void 0 ? _b : node.name);
+        this._reportDeprecatedUse(node.name, type, isImportFromTyping);
         return false;
     }
     visitModuleName(node) {
@@ -1928,17 +1908,25 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         implementationFunction = type;
                     }
                     if (!implementationFunction) {
-                        let isProtocolMethod = false;
+                        let exemptMissingImplementation = false;
                         const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
                         if (containingClassNode && containingClassNode.nodeType === 10 /* Class */) {
                             const classType = this._evaluator.getTypeOfClass(containingClassNode);
-                            if (classType && types_1.ClassType.isProtocolClass(classType.classType)) {
-                                isProtocolMethod = true;
+                            if (classType) {
+                                if (types_1.ClassType.isProtocolClass(classType.classType)) {
+                                    exemptMissingImplementation = true;
+                                }
+                                else if (types_1.ClassType.supportsAbstractMethods(classType.classType)) {
+                                    if ((0, types_1.isOverloadedFunction)(type) &&
+                                        types_1.OverloadedFunctionType.getOverloads(type).every((overload) => types_1.FunctionType.isAbstractMethod(overload))) {
+                                        exemptMissingImplementation = true;
+                                    }
+                                }
                             }
                         }
                         // If this is a method within a protocol class, don't require that
                         // there is an implementation.
-                        if (!isProtocolMethod) {
+                        if (!exemptMissingImplementation) {
                             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadWithoutImplementation().format({
                                 name: primaryDecl.node.name.value,
                             }), primaryDecl.node.name);
@@ -2632,8 +2620,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
-    _reportDeprecatedUse(node, type) {
-        var _a;
+    _reportDeprecatedUse(node, type, isImportFromTyping = false) {
+        var _a, _b;
         if (!type) {
             return;
         }
@@ -2710,24 +2698,25 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDeprecated, diagnosticRules_1.DiagnosticRule.reportDeprecated, errorMessage + diag.getString(), node);
             }
         }
-        // We'll leave this disabled for now because this would be too noisy for most
-        // code bases. We may want to add it at some future date.
-        if (0) {
-            const deprecatedForm = (_a = deprecatedAliases.get(node.value)) !== null && _a !== void 0 ? _a : deprecatedSpecialForms.get(node.value);
+        if (this._fileInfo.diagnosticRuleSet.deprecateTypingAliases) {
+            const deprecatedForm = (_a = deprecatedSymbols_1.deprecatedAliases.get(node.value)) !== null && _a !== void 0 ? _a : deprecatedSymbols_1.deprecatedSpecialForms.get(node.value);
             if (deprecatedForm) {
-                if ((0, types_1.isInstantiableClass)(type) && type.details.fullName === deprecatedForm.fullName) {
+                if (((0, types_1.isInstantiableClass)(type) && type.details.fullName === deprecatedForm.fullName) ||
+                    ((_b = type.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName) === deprecatedForm.fullName) {
                     if (this._fileInfo.executionEnvironment.pythonVersion >= deprecatedForm.version) {
-                        if (this._fileInfo.diagnosticRuleSet.reportDeprecated === 'none') {
-                            this._evaluator.addDeprecated(localize_1.Localizer.Diagnostic.deprecatedType().format({
-                                version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
-                                replacement: deprecatedForm.replacementText,
-                            }), node);
-                        }
-                        else {
-                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDeprecated, diagnosticRules_1.DiagnosticRule.reportDeprecated, localize_1.Localizer.Diagnostic.deprecatedType().format({
-                                version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
-                                replacement: deprecatedForm.replacementText,
-                            }), node);
+                        if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
+                            if (this._fileInfo.diagnosticRuleSet.reportDeprecated === 'none') {
+                                this._evaluator.addDeprecated(localize_1.Localizer.Diagnostic.deprecatedType().format({
+                                    version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
+                                    replacement: deprecatedForm.replacementText,
+                                }), node);
+                            }
+                            else {
+                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDeprecated, diagnosticRules_1.DiagnosticRule.reportDeprecated, localize_1.Localizer.Diagnostic.deprecatedType().format({
+                                    version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
+                                    replacement: deprecatedForm.replacementText,
+                                }), node);
+                            }
                         }
                     }
                 }
@@ -3611,6 +3600,68 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    // Verifies that classes that have more than one base class do not have
+    // have conflicting type arguments.
+    _validateMultipleInheritanceBaseClasses(classType, errorNode) {
+        // Skip this check if the class has only one base class or one or more
+        // of the base classes are Any.
+        const filteredBaseClasses = [];
+        for (const baseClass of classType.details.baseClasses) {
+            if (!(0, types_1.isClass)(baseClass)) {
+                return;
+            }
+            if (!types_1.ClassType.isBuiltIn(baseClass, ['Generic', 'Protocol', 'object'])) {
+                filteredBaseClasses.push(baseClass);
+            }
+        }
+        if (filteredBaseClasses.length < 2) {
+            return;
+        }
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        for (const baseClass of filteredBaseClasses) {
+            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            for (const baseClassMroClass of baseClass.details.mro) {
+                // There's no need to check for conflicts if this class isn't generic.
+                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.details.typeParameters.length > 0) {
+                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
+                    // Find the corresponding class in the derived class's MRO list.
+                    const matchingMroClass = classType.details.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);
+                        // If the types match exactly, we can shortcut the remainder of the MRO chain.
+                        // if (isTypeSame(matchingMroObject, baseClassMroObject)) {
+                        //     break;
+                        // }
+                        if (!this._evaluator.assignType(matchingMroObject, baseClassMroObject)) {
+                            const diag = new diagnostic_1.DiagnosticAddendum();
+                            const baseClassObject = (0, typeUtils_1.convertToInstance)(baseClass);
+                            if ((0, types_1.isTypeSame)(baseClassObject, baseClassMroObject)) {
+                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.baseClassIncompatible().format({
+                                    baseClass: this._evaluator.printType(baseClassObject),
+                                    type: this._evaluator.printType(matchingMroObject),
+                                }));
+                            }
+                            else {
+                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.baseClassIncompatibleSubclass().format({
+                                    baseClass: this._evaluator.printType(baseClassObject),
+                                    subclass: this._evaluator.printType(baseClassMroObject),
+                                    type: this._evaluator.printType(matchingMroObject),
+                                }));
+                            }
+                            diagAddendum.addAddendum(diag);
+                            // Break out of the inner loop so we don't report any redundant errors for this base class.
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!diagAddendum.isEmpty()) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassIncompatible().format({ type: classType.details.name }) +
+                diagAddendum.getString(), errorNode);
+        }
+    }
     // Validates that any methods and variables in multiple base classes are
     // compatible with each other.
     _validateMultipleInheritanceCompatibility(classType, errorNode) {
@@ -3888,10 +3939,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
+        var _a, _b;
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
-        if (baseClassAndSymbol.symbol.isIgnoredForOverrideChecks()) {
+        if (baseClassAndSymbol.symbol.isIgnoredForOverrideChecks() || overrideSymbol.isIgnoredForOverrideChecks()) {
             return;
         }
         // If the base class doesn't provide a type declaration, we won't bother
@@ -4051,7 +4103,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
                             name: memberName,
                             className: baseClassAndSymbol.classType.details.name,
-                        }) + diagAddendum.getString(), lastDecl.node);
+                        }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
@@ -4093,7 +4145,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
                             className: baseClassAndSymbol.classType.details.name,
-                        }), lastDecl.node);
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
@@ -4336,7 +4388,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // Determines whether a yield or yield from node is compatible with the
     // return type annotation of the containing function.
-    _validateYieldType(node, yieldType) {
+    _validateYieldType(node, yieldType, sendType) {
         var _a;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         if (!enclosingFunctionNode || !enclosingFunctionNode.returnTypeAnnotation) {
@@ -4371,7 +4423,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsYield(), node);
             return;
         }
-        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, [yieldType], /* isTypeArgumentExplicit */ true));
+        const generatorTypeArgs = [yieldType, sendType !== null && sendType !== void 0 ? sendType : types_1.UnknownType.create(), types_1.UnknownType.create()];
+        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, generatorTypeArgs, /* isTypeArgumentExplicit */ true));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
             const errorMessage = enclosingFunctionNode.isAsync