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

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);
@@ -3626,35 +3627,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 +3664,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 +3675,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 +3697,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 +3713,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 +3989,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 +4001,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 +4027,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 +4035,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 +4154,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 +4187,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 +4318,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) {