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

package/dist/analyzer/checker.js

@@ -1048,6 +1048,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Type stub found, but source is missing.
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingModuleSource, diagnosticRules_1.DiagnosticRule.reportMissingModuleSource, localize_1.Localizer.Diagnostic.importSourceResolveFailure().format({
             importName: importResult.importName,
+            venv: this._fileInfo.executionEnvironment.name,
         }), node);
     }
     _validateConditionalIsBool(node) {
@@ -1104,15 +1105,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const exprTypeResult = this._evaluator.getTypeOfExpression(expression);
         let isExprFunction = true;
+        let isCoroutine = false;
         (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
                 isExprFunction = false;
             }
+            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Coroutine')) {
+                isCoroutine = true;
+            }
         });
         if (isExprFunction) {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.functionInConditionalExpression(), expression);
         }
+        if (isCoroutine) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.coroutineInConditionalExpression(), expression);
+        }
     }
     _reportUnusedExpression(node) {
         var _a, _b;
@@ -1989,18 +1997,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // is implicitly initialized by the synthesized `__init__` method and
                 // therefore has an implied assignment.
                 let isImplicitlyAssigned = false;
+                // Is this a class variable within a protocol class? If so, it can
+                // be marked final without providing a value.
+                let isProtocolClass = false;
                 if (symbol.isClassMember() && !symbol.isClassVar()) {
                     const containingClass = ParseTreeUtils.getEnclosingClass(firstDecl.node, /* stopAtFunction */ true);
                     if (containingClass) {
                         const classType = this._evaluator.getTypeOfClass(containingClass);
-                        if (classType &&
-                            (0, types_1.isClass)(classType.decoratedType) &&
-                            types_1.ClassType.isDataClass(classType.decoratedType)) {
-                            isImplicitlyAssigned = true;
+                        if (classType && (0, types_1.isClass)(classType.decoratedType)) {
+                            if (types_1.ClassType.isDataClass(classType.decoratedType)) {
+                                isImplicitlyAssigned = true;
+                            }
+                            if (types_1.ClassType.isProtocolClass(classType.decoratedType)) {
+                                isProtocolClass = true;
+                            }
                         }
                     }
                 }
-                if (!isImplicitlyAssigned) {
+                if (!isImplicitlyAssigned && !isProtocolClass) {
                     this._evaluator.addError(localize_1.Localizer.Diagnostic.finalUnassigned().format({ name }), firstDecl.node);
                 }
             }
@@ -2491,7 +2505,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // derives from an unknown type. In this case, we'll add an
                 // unknown type into the filtered type list to avoid any
                 // false positives.
-                const isClassRelationshipIndeterminate = filterIsSubclass && filterIsSubclass && !types_1.ClassType.isSameGenericClass(varType, filterType);
+                const isClassRelationshipIndeterminate = filterIsSuperclass && filterIsSubclass && !types_1.ClassType.isSameGenericClass(varType, filterType);
                 if (isClassRelationshipIndeterminate) {
                     filteredTypes.push(types_1.UnknownType.create());
                 }
@@ -2627,6 +2641,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         let errorMessage;
         let deprecatedMessage;
+        function getDeprecatedMessageForFunction(functionType) {
+            if (functionType.details.declaration &&
+                functionType.details.declaration.node.nodeType === 28 /* Function */) {
+                const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
+                /* stopAtFunction */ true);
+                if (containingClass) {
+                    return localize_1.Localizer.Diagnostic.deprecatedMethod().format({
+                        name: functionType.details.name || '<anonymous>',
+                        className: containingClass.name.value,
+                    });
+                }
+            }
+            return localize_1.Localizer.Diagnostic.deprecatedFunction().format({
+                name: functionType.details.name,
+            });
+        }
         function getDeprecatedMessageForOverloadedCall(evaluator, type) {
             // Determine if the node is part of a call expression. If so,
             // we can determine which overload(s) were used to satisfy
@@ -2642,9 +2672,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (overload.details.deprecatedMessage !== undefined) {
                             if (node.value === overload.details.name) {
                                 deprecatedMessage = overload.details.deprecatedMessage;
-                                errorMessage = localize_1.Localizer.Diagnostic.deprecatedFunction().format({
-                                    name: overload.details.name,
-                                });
+                                errorMessage = getDeprecatedMessageForFunction(overload);
                             }
                             else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
                                 deprecatedMessage = overload.details.deprecatedMessage;
@@ -2673,9 +2701,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else if ((0, types_1.isFunction)(subtype)) {
                 if (subtype.details.deprecatedMessage !== undefined && node.value === subtype.details.name) {
                     deprecatedMessage = subtype.details.deprecatedMessage;
-                    errorMessage = localize_1.Localizer.Diagnostic.deprecatedFunction().format({
-                        name: subtype.details.name || '<anonymous>',
-                    });
+                    errorMessage = getDeprecatedMessageForFunction(subtype);
                 }
             }
             else if ((0, types_1.isOverloadedFunction)(subtype)) {
@@ -3177,7 +3203,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!types_1.ClassType.isDataClass(classType)) {
             return;
         }
-        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 16 /* DeclaredTypesOnly */);
+        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 32 /* DeclaredTypesOnly */);
         // If there's no __post_init__ method, there's nothing to check.
         if (!postInitMember) {
             return;
@@ -3507,7 +3533,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // __call__ method, skip this check.
         const metaclass = newMember.classType.details.effectiveMetaclass;
         if (metaclass && (0, types_1.isClass)(metaclass) && !types_1.ClassType.isBuiltIn(metaclass, 'type')) {
-            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 32 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
+            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 64 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
             if (callMethod) {
                 return;
             }