@zzzen/pyright-internal 1.2.0-dev.20250209 → 1.2.0-dev.20250216

package/dist/analyzer/checker.d.ts

@@ -81,7 +81,6 @@ export declare class Checker extends ParseTreeWalker {
     private _validateStandardCollectionInstantiation;
     private _validateContainmentTypes;
     private _validateComparisonTypes;
-    private _isTypeComparable;
     private _validateGeneratorReturnType;
     private _isTypeValidForUnusedValueTest;
     private _validateFunctionTypeVarUsage;
@@ -148,6 +147,7 @@ export declare class Checker extends ParseTreeWalker {
     private _isMethodExemptFromLsp;
     private _validateOverrideDecoratorNotPresent;
     private _validateBaseClassOverride;
+    private _isFinalFunction;
     private _validatePropertyOverride;
     private _validateMethod;
     private _validateSuperCallForMethod;

package/dist/analyzer/checker.js

@@ -1382,7 +1382,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (isComparable) {
                         return;
                     }
-                    if (this._isTypeComparable(leftSubtype, rightSubtype)) {
+                    if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype)) {
                         isComparable = true;
                     }
                     return rightSubtype;
@@ -1399,71 +1399,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    // Determines whether the two types are potentially comparable -- i.e.
-    // their types overlap in such a way that it makes sense for them to
-    // be compared with an == or != operator.
-    _isTypeComparable(leftType, rightType) {
-        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
-            return true;
-        }
-        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-            return false;
-        }
-        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
-            return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
-        }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
-        if (isLeftCallable !== isRightCallable) {
-            return false;
-        }
-        if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
-            if ((0, types_1.isInstantiableClass)(rightType) ||
-                ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
-                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
-                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
-                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
-                    this._evaluator.assignType(genericRightType, genericLeftType)) {
-                    return true;
-                }
-            }
-            // Does the class have an operator overload for eq?
-            const metaclass = leftType.shared.effectiveMetaclass;
-            if (metaclass && (0, types_1.isClass)(metaclass)) {
-                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        if ((0, types_1.isClassInstance)(leftType)) {
-            if ((0, types_1.isClass)(rightType)) {
-                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
-                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
-                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
-                    this._evaluator.assignType(genericRightType, genericLeftType)) {
-                    return true;
-                }
-                // Assume that if the types are disjoint and built-in classes that they
-                // will never be comparable.
-                if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
-                    return false;
-                }
-            }
-            // Does the class have an operator overload for eq?
-            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
-            if (eqMethod) {
-                // If this is a synthesized method for a dataclass, we can assume
-                // that other dataclass types will not be comparable.
-                if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
-                    return false;
-                }
-                return true;
-            }
-            return false;
-        }
-        return true;
-    }
     // If the function is a generator, validates that its annotated return type
     // is appropriate for a generator.
     _validateGeneratorReturnType(node, functionType) {
@@ -4631,24 +4566,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Determine whether this is an attempt to override a method marked @final.
-            let reportFinalMethodOverride = false;
-            // Private names (starting with double underscore) are exempt from this check.
-            if (!SymbolNameUtils.isPrivateName(memberName)) {
-                if ((0, types_1.isFunction)(baseType) && types_1.FunctionType.isFinal(baseType)) {
-                    reportFinalMethodOverride = true;
-                }
-                else if ((0, types_1.isOverloaded)(baseType)) {
-                    const overloads = types_1.OverloadedType.getOverloads(baseType);
-                    const impl = types_1.OverloadedType.getImplementation(baseType);
-                    if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
-                        reportFinalMethodOverride = true;
-                    }
-                    if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
-                        reportFinalMethodOverride = true;
-                    }
-                }
-            }
-            if (reportFinalMethodOverride) {
+            if (this._isFinalFunction(memberName, baseType)) {
                 const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
                 if (decl && decl.type === 5 /* DeclarationType.Function */) {
                     const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
@@ -4857,6 +4775,25 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    _isFinalFunction(name, type) {
+        if (SymbolNameUtils.isPrivateName(name)) {
+            return false;
+        }
+        if ((0, types_1.isFunction)(type) && types_1.FunctionType.isFinal(type)) {
+            return true;
+        }
+        if ((0, types_1.isOverloaded)(type)) {
+            const overloads = types_1.OverloadedType.getOverloads(type);
+            const impl = types_1.OverloadedType.getImplementation(type);
+            if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+                return true;
+            }
+            if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
+                return true;
+            }
+        }
+        return false;
+    }
     _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
             ['fget', (c) => c.priv.fgetInfo?.methodType],
@@ -4893,6 +4830,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     return;
                 }
+                else if (this._isFinalFunction(methodName, baseClassPropMethod)) {
+                    const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
+                    if (decl && decl.type === 5 /* DeclarationType.Function */) {
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
+                            name: memberName,
+                            className: baseClassType.shared.name,
+                        }), decl.node.d.name);
+                    }
+                }
                 const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
                 if (!(0, types_1.isFunction)(subclassMethodType)) {
                     return;