@zzzen/pyright-internal 1.2.0-dev.20231105 → 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

@@ -46,6 +46,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 constructors_1 = require("./constructors");
 const declaration_1 = require("./declaration");
 const declarationUtils_1 = require("./declarationUtils");
 const deprecatedSymbols_1 = require("./deprecatedSymbols");
@@ -176,7 +177,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateBaseClassOverrides(classTypeResult.classType);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
-            this._validateConstructorConsistency(classTypeResult.classType);
+            this._validateConstructorConsistency(classTypeResult.classType, node.name);
             this._validateFinalMemberOverrides(classTypeResult.classType);
             this._validateInstanceVariableInitialization(node, classTypeResult.classType);
             this._validateFinalClassNotAbstract(classTypeResult.classType, node);
@@ -2460,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),
@@ -2555,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;
         }
@@ -2651,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);
@@ -2663,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;
             }
@@ -3156,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)) {
@@ -3200,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) {
@@ -3626,35 +3639,34 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     // Validates that the __init__ and __new__ method signatures are consistent.
-    _validateConstructorConsistency(classType) {
-        const initMember = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */ | 16 /* SkipInstanceMembers */);
-        const newMember = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 4 /* SkipObjectBaseClass */ | 16 /* SkipInstanceMembers */);
-        if (!initMember || !newMember || !(0, types_1.isClass)(initMember.classType) || !(0, types_1.isClass)(newMember.classType)) {
+    _validateConstructorConsistency(classType, errorNode) {
+        // If the class has a custom metaclass with a __call__ method, skip this check.
+        const callMethodResult = (0, constructors_1.getBoundCallMethod)(this._evaluator, errorNode, classType);
+        if (callMethodResult) {
             return;
         }
-        // If both the __new__ and __init__ come from subclasses, don't bother
-        // checking for this class.
-        if (!types_1.ClassType.isSameGenericClass(newMember.classType, classType) &&
-            !types_1.ClassType.isSameGenericClass(initMember.classType, classType)) {
+        const newMethodResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, errorNode, classType);
+        if (!newMethodResult ||
+            newMethodResult.typeErrors ||
+            !newMethodResult.classType ||
+            !(0, types_1.isClass)(newMethodResult.classType)) {
             return;
         }
-        // If the class that provides the __new__ method has a custom metaclass with a
-        // __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__', 8 /* SkipTypeBaseClass */ | 16 /* SkipInstanceMembers */);
-            if (callMethod) {
-                return;
-            }
+        const initMethodResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, errorNode, types_1.ClassType.cloneAsInstance(classType));
+        if (!initMethodResult ||
+            initMethodResult.typeErrors ||
+            !initMethodResult.classType ||
+            !(0, types_1.isClass)(initMethodResult.classType)) {
+            return;
         }
-        let newMemberType = this._evaluator.getTypeOfMember(newMember);
-        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloadedFunction)(newMemberType)) {
+        // If both the __new__ and __init__ come from subclasses, don't bother
+        // checking for this class.
+        if (!types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType) &&
+            !types_1.ClassType.isSameGenericClass(newMethodResult.classType, classType)) {
             return;
         }
-        newMemberType = this._evaluator.bindFunctionToClassOrObject(classType, newMemberType, 
-        /* memberClass */ undefined, 
-        /* treatConstructorAsClassMember */ true);
-        if (!newMemberType) {
+        let newMemberType = newMethodResult.type;
+        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloadedFunction)(newMemberType)) {
             return;
         }
         if ((0, types_1.isOverloadedFunction)(newMemberType)) {
@@ -3664,14 +3676,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
         }
-        let initMemberType = this._evaluator.getTypeOfMember(initMember);
+        let initMemberType = initMethodResult.type;
         if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloadedFunction)(initMemberType)) {
             return;
         }
-        initMemberType = this._evaluator.bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), initMemberType);
-        if (!initMemberType) {
-            return;
-        }
         if ((0, types_1.isOverloadedFunction)(initMemberType)) {
             // Find the implementation, not the overloaded signatures.
             initMemberType = types_1.OverloadedFunctionType.getImplementation(initMemberType);
@@ -3679,9 +3687,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
         }
-        if (!(0, types_1.isFunction)(initMemberType) || !(0, types_1.isFunction)(newMemberType)) {
-            return;
-        }
         // If either of the functions has a default parameter signature
         // (* args: Any, ** kwargs: Any), don't proceed with the check.
         if (types_1.FunctionType.hasDefaultParameters(initMemberType) || types_1.FunctionType.hasDefaultParameters(newMemberType)) {
@@ -3704,9 +3709,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */)) {
-            const displayOnInit = types_1.ClassType.isSameGenericClass(initMember.classType, classType);
-            const initDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(initMember.symbol);
-            const newDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(newMember.symbol);
+            const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
+            const initDecl = initMemberType.details.declaration;
+            const newDecl = newMemberType.details.declaration;
             if (initDecl && newDecl) {
                 const mainDecl = displayOnInit ? initDecl : newDecl;
                 const mainDeclNode = mainDecl.node.nodeType === 28 /* Function */ ? mainDecl.node.name : mainDecl.node;
@@ -3720,14 +3725,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     type: newSignature,
                 }));
                 const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInconsistentConstructor, diagnosticRules_1.DiagnosticRule.reportInconsistentConstructor, localize_1.Localizer.Diagnostic.constructorParametersMismatch().format({
-                    classType: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? initMember.classType : newMember.classType)),
+                    classType: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? initMethodResult.classType : newMethodResult.classType)),
                 }) + diagAddendum.getString(), mainDeclNode);
                 if (diagnostic) {
                     const secondaryDecl = displayOnInit ? newDecl : initDecl;
                     diagnostic.addRelatedInfo((displayOnInit
                         ? localize_1.Localizer.DiagnosticAddendum.newMethodLocation()
                         : localize_1.Localizer.DiagnosticAddendum.initMethodLocation()).format({
-                        type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMember.classType : initMember.classType)),
+                        type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMethodResult.classType : initMethodResult.classType)),
                     }), secondaryDecl.path, secondaryDecl.range);
                 }
             }
@@ -3996,7 +4001,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateOverrideDecoratorPresent(symbol, overrideType, baseMember) {
-        var _a;
         // Skip this check if disabled.
         if (this._fileInfo.diagnosticRuleSet.reportImplicitOverride === 'none') {
             return;
@@ -4009,12 +4013,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            const fgetSymbol = overrideType.details.fields.get('fget');
-            if (fgetSymbol) {
-                const fgetType = (_a = this._evaluator.getDeclaredTypeOfSymbol(fgetSymbol)) === null || _a === void 0 ? void 0 : _a.type;
-                if (fgetType && (0, types_1.isFunction)(fgetType)) {
-                    overrideFunction = fgetType;
-                }
+            if (overrideType.fgetFunction) {
+                overrideFunction = overrideType.fgetFunction;
             }
         }
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || types_1.FunctionType.isOverridden(overrideFunction)) {
@@ -4039,7 +4039,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // decorator. In this case, an error is reported because no base class has declared
     // a method of the same name.
     _validateOverrideDecoratorNotPresent(symbol, overrideType) {
-        var _a;
         let overrideFunction;
         if ((0, types_1.isFunction)(overrideType)) {
             overrideFunction = overrideType;
@@ -4048,12 +4047,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            const fgetSymbol = overrideType.details.fields.get('fget');
-            if (fgetSymbol) {
-                const fgetType = (_a = this._evaluator.getDeclaredTypeOfSymbol(fgetSymbol)) === null || _a === void 0 ? void 0 : _a.type;
-                if (fgetType && (0, types_1.isFunction)(fgetType)) {
-                    overrideFunction = fgetType;
-                }
+            if (overrideType.fgetFunction) {
+                overrideFunction = overrideType.fgetFunction;
             }
         }
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
@@ -4171,16 +4166,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else {
-                const basePropFields = baseType.details.fields;
-                const subclassPropFields = overrideType.details.fields;
                 const baseClassType = baseClass;
-                ['fget', 'fset', 'fdel'].forEach((methodName) => {
+                const propMethodInfo = [
+                    ['fget', (c) => c.fgetFunction],
+                    ['fset', (c) => c.fsetFunction],
+                    ['fdel', (c) => c.fdelFunction],
+                ];
+                propMethodInfo.forEach((info) => {
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                    const baseClassPropMethod = basePropFields.get(methodName);
-                    const subclassPropMethod = subclassPropFields.get(methodName);
+                    const [methodName, methodAccessor] = info;
+                    const baseClassPropMethod = methodAccessor(baseType);
+                    const subclassPropMethod = methodAccessor(overrideType);
                     // Is the method present on the base class but missing in the subclass?
                     if (baseClassPropMethod) {
-                        const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassPropMethod), baseClassType);
+                        const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType);
                         if ((0, types_1.isFunction)(baseClassMethodType)) {
                             if (!subclassPropMethod) {
                                 // The method is missing.
@@ -4200,7 +4199,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 }
                             }
                             else {
-                                const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(subclassPropMethod), childClassType);
+                                const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType);
                                 if ((0, types_1.isFunction)(subclassMethodType)) {
                                     if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                         diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodIncompatible().format({
@@ -4331,7 +4330,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // __new__ overrides should have a "cls" parameter.
             if (node.parameters.length === 0 ||
                 !node.parameters[0].name ||
-                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs'].some((name) => node.parameters[0].name.value === name)) {
+                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs', 'metacls'].some((name) => node.parameters[0].name.value === name)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
             }
             if (classType) {