@zzzen/pyright-internal 1.2.0-dev.20231112 → 1.2.0-dev.20231119

package/dist/analyzer/checker.d.ts

@@ -115,6 +115,7 @@ export declare class Checker extends ParseTreeWalker {
     private _validateTypeGuardFunction;
     private _validateDunderSignatures;
     private _validateFunctionReturn;
+    private _validateReturnTypeIsNotContravariant;
     private _reportUnknownReturnResult;
     private _validateFinalMemberOverrides;
     private _reportDuplicateEnumMembers;

package/dist/analyzer/checker.js

@@ -2461,21 +2461,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let isValidType = true;
+        const diag = new diagnostic_1.DiagnosticAddendum();
         (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
             if ((0, types_1.isClassInstance)(arg1Subtype) && types_1.ClassType.isTupleClass(arg1Subtype) && arg1Subtype.tupleTypeArguments) {
-                if (arg1Subtype.tupleTypeArguments.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck))) {
+                if (arg1Subtype.tupleTypeArguments.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck, diag))) {
                     isValidType = false;
                 }
             }
             else {
-                if (!this._isTypeSupportedTypeForIsInstance(arg1Subtype, isInstanceCheck)) {
+                if (!this._isTypeSupportedTypeForIsInstance(arg1Subtype, isInstanceCheck, diag)) {
                     isValidType = false;
                 }
             }
         });
         if (!isValidType) {
-            const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarNotAllowed());
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, isInstanceCheck
                 ? localize_1.Localizer.Diagnostic.isInstanceInvalidType().format({
                     type: this._evaluator.printType(arg1Type),
@@ -2556,12 +2555,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!isValidType) {
             return;
         }
-        // According to PEP 544, protocol classes cannot be used as the right-hand
-        // argument to isinstance or issubclass unless they are annotated as
-        // "runtime checkable".
-        if (classTypeList.some((type) => types_1.ClassType.isProtocolClass(type) && !types_1.ClassType.isRuntimeCheckable(type))) {
-            this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolUsedInCall().format({ name: callName }), node.arguments[1].valueExpression);
-        }
         if ((0, typeUtils_1.derivesFromAnyOrUnknown)(arg0Type)) {
             return;
         }
@@ -2652,7 +2645,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // Determines whether the specified type is allowed as the second argument
     // to an isinstance or issubclass check.
-    _isTypeSupportedTypeForIsInstance(type, isInstanceCheck) {
+    _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
         let isSupported = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
@@ -2664,23 +2657,33 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     break;
                 case 6 /* Class */:
                     if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noneNotAllowed());
                         isSupported = false;
                     }
                     else if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
                         // If it's a class, make sure that it has not been given explicit
                         // type arguments. This will result in a TypeError exception.
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.genericClassNotAllowed());
+                        isSupported = false;
+                    }
+                    else if (types_1.ClassType.isProtocolClass(subtype) &&
+                        !types_1.ClassType.isRuntimeCheckable(subtype) &&
+                        !subtype.includeSubclasses) {
+                        // According to PEP 544, protocol classes cannot be used as the right-hand
+                        // argument to isinstance or issubclass unless they are annotated as
+                        // "runtime checkable".
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolRequiresRuntimeCheckable());
                         isSupported = false;
                     }
                     break;
                 case 4 /* Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
                     break;
-                case 8 /* Union */:
-                    isSupported = this._isTypeSupportedTypeForIsInstance(subtype, isInstanceCheck);
-                    break;
-                default:
+                case 9 /* TypeVar */:
+                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarNotAllowed());
                     isSupported = false;
                     break;
             }
@@ -3157,10 +3160,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             let declaredReturnType = functionType.details.declaredReturnType;
             if (declaredReturnType) {
                 this._reportUnknownReturnResult(node, declaredReturnType);
-                if ((0, types_1.isTypeVar)(declaredReturnType) &&
-                    declaredReturnType.details.declaredVariance === 4 /* Contravariant */) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeContravariant(), returnAnnotation);
-                }
+                this._validateReturnTypeIsNotContravariant(declaredReturnType, returnAnnotation);
             }
             // Wrap the declared type in a generator type if the function is a generator.
             if (types_1.FunctionType.isGenerator(functionType)) {
@@ -3201,6 +3201,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         else {
             const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
             this._reportUnknownReturnResult(node, inferredReturnType);
+            this._validateReturnTypeIsNotContravariant(inferredReturnType, node.name);
+        }
+    }
+    _validateReturnTypeIsNotContravariant(returnType, errorNode) {
+        let isContraTypeVar = false;
+        (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
+            if ((0, types_1.isTypeVar)(subtype) && subtype.details.declaredVariance === 4 /* Contravariant */) {
+                isContraTypeVar = true;
+            }
+        });
+        if (isContraTypeVar) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeContravariant(), errorNode);
         }
     }
     _reportUnknownReturnResult(node, returnType) {