@zzzen/pyright-internal 1.2.0-dev.20230611 → 1.2.0-dev.20230618

package/dist/analyzer/checker.js

@@ -3738,7 +3738,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             if (overrideFunction) {
-                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, diagAddendum, 
+                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, 
+                /* baseClass */ undefined, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
                     const decl = overrideFunction.details.declaration;
                     if (decl && decl.type === 5 /* Function */) {
@@ -3826,6 +3827,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!mroBaseClass) {
                     continue;
                 }
+                (0, debug_1.assert)((0, types_1.isClass)(mroBaseClass));
                 const baseClassAndSymbol = (0, typeUtils_1.lookUpClassMember)(mroBaseClass, name, 0 /* Default */);
                 if (!baseClassAndSymbol) {
                     continue;
@@ -3945,7 +3947,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Don't check certain magic functions or private symbols.
                 if (!exemptMethods.some((exempt) => exempt === memberName) &&
                     !SymbolNameUtils.isPrivateName(memberName)) {
-                    if (!this._evaluator.validateOverrideMethod(baseType, overrideType, diagAddendum, enforceParamNameMatch)) {
+                    if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
                         const decl = (0, types_1.isFunction)(overrideType) && overrideType.details.declaration
                             ? overrideType.details.declaration
                             : (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
@@ -4042,7 +4044,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             else {
                                 const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(subclassPropMethod), childClassType);
                                 if ((0, types_1.isFunction)(subclassMethodType)) {
-                                    if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, diagAddendum.createAddendum())) {
+                                    if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                         diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodIncompatible().format({
                                             name: methodName,
                                         }));
@@ -4331,6 +4333,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isClassInstance)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
             return;
         }
+        // If the method starts with a `*args: P.args`, skip the check.
+        if (paramInfo.category === 1 /* ArgsList */ &&
+            (0, types_1.isParamSpec)(paramInfo.type) &&
+            paramInfo.type.paramSpecAccess === 'args') {
+            return;
+        }
         // Don't enforce this for an overloaded method because the "self" param
         // annotation can be used as a filter for the overload. This differs from
         // mypy, which enforces this check for overloads, but there are legitimate