Improved overload overlap logic to detect partial overlaps when parameter types include unions that intersect. This addresses #6825. (#6856)

Author: erictraut

packages/pyright-internal/src/analyzer/checker.ts

@@ -2601,7 +2601,7 @@ export class Checker extends ParseTreeWalker {
     ) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (this._isOverlappingOverload(functionType, prevOverload)) {
+            if (this._isOverlappingOverload(functionType, prevOverload, /* partialOverlap */ false)) {
                 this._evaluator.addDiagnostic(
                     this._fileInfo.diagnosticRuleSet.reportOverlappingOverload,
                     DiagnosticRule.reportOverlappingOverload,
@@ -2618,7 +2618,7 @@ export class Checker extends ParseTreeWalker {
 
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (this._isOverlappingOverload(prevOverload, functionType)) {
+            if (this._isOverlappingOverload(prevOverload, functionType, /* partialOverlap */ true)) {
                 const prevReturnType = FunctionType.getSpecializedReturnType(prevOverload);
                 const returnType = FunctionType.getSpecializedReturnType(functionType);
 
@@ -2672,7 +2672,7 @@ export class Checker extends ParseTreeWalker {
         return undefined;
     }
 
-    private _isOverlappingOverload(functionType: FunctionType, prevOverload: FunctionType) {
+    private _isOverlappingOverload(functionType: FunctionType, prevOverload: FunctionType, partialOverlap: boolean) {
         // According to precedent, the __get__ method is special-cased and is
         // exempt from overlapping overload checks. It's not clear why this is
         // the case, but for consistency with other type checkers, we'll honor
@@ -2682,13 +2682,18 @@ export class Checker extends ParseTreeWalker {
             return false;
         }
 
+        let flags = AssignTypeFlags.SkipFunctionReturnTypeCheck | AssignTypeFlags.OverloadOverlapCheck;
+        if (partialOverlap) {
+            flags |= AssignTypeFlags.PartialOverloadOverlapCheck;
+        }
+
         return this._evaluator.assignType(
             functionType,
             prevOverload,
             /* diag */ undefined,
             new TypeVarContext(getTypeVarScopeId(functionType)),
             /* srcTypeVarContext */ undefined,
-            AssignTypeFlags.SkipFunctionReturnTypeCheck | AssignTypeFlags.OverloadOverlapCheck
+            flags
         );
     }
 

packages/pyright-internal/src/analyzer/protocols.ts

@@ -278,7 +278,7 @@ function assignClassToProtocolInternal(
 
     let typesAreConsistent = true;
     const checkedSymbolSet = new Set<string>();
-    let assignTypeFlags = flags & AssignTypeFlags.OverloadOverlapCheck;
+    let assignTypeFlags = flags & (AssignTypeFlags.OverloadOverlapCheck | AssignTypeFlags.PartialOverloadOverlapCheck);
 
     assignTypeFlags |= containsLiteralType(srcType, /* includeTypeArgs */ true)
         ? AssignTypeFlags.RetainLiteralsForTypeVar

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -23462,6 +23462,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
         // Sort the subtypes so we have a deterministic order for unions.
         let sortedSrcTypes: Type[] = sortTypes(srcType.subtypes);
+        let matchedSomeSubtypes = false;
 
         // Handle the case where the source and dest are both unions. Try
         // to eliminate as many exact type matches between the src and dest.
@@ -23501,6 +23502,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
                     if (srcTypeIndex >= 0) {
                         remainingSrcSubtypes.splice(srcTypeIndex, 1);
+                        matchedSomeSubtypes = true;
                     } else {
                         remainingDestSubtypes.push(destSubtype);
                     }
@@ -23553,7 +23555,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
                 if (destTypeIndex >= 0) {
                     if (
-                        !assignType(
+                        assignType(
                             remainingDestSubtypes[destTypeIndex],
                             srcSubtype,
                             diag?.createAddendum(),
@@ -23563,6 +23565,10 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                             recursionCount
                         )
                     ) {
+                        // Note that we have matched at least one subtype indicating
+                        // there is at least some overlap.
+                        matchedSomeSubtypes = true;
+                    } else {
                         canUseFastPath = false;
                     }
 
@@ -23661,6 +23667,12 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
             if (canUseFastPath) {
                 return true;
             }
+
+            // If we're looking for type overlaps and at least one type was matched,
+            // consider it as assignable.
+            if ((flags & AssignTypeFlags.PartialOverloadOverlapCheck) !== 0 && matchedSomeSubtypes) {
+                return true;
+            }
         }
 
         let isIncompatible = false;
@@ -23705,10 +23717,18 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 ) {
                     isIncompatible = true;
                 }
+            } else {
+                matchedSomeSubtypes = true;
             }
         }, /* sortSubtypes */ true);
 
         if (isIncompatible) {
+            // If we're looking for type overlaps and at least one type was matched,
+            // consider it as assignable.
+            if ((flags & AssignTypeFlags.PartialOverloadOverlapCheck) !== 0 && matchedSomeSubtypes) {
+                return true;
+            }
+
             diag?.addMessage(
                 Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType))
             );

packages/pyright-internal/src/analyzer/typeUtils.ts

@@ -180,46 +180,51 @@ export const enum AssignTypeFlags {
     // whether overload signatures overlap.
     OverloadOverlapCheck = 1 << 4,
 
+    // When used in conjunction with OverloadOverlapCheck, look
+    // for partial overlaps. For example, `int | list` overlaps
+    // partially with `int | str`.
+    PartialOverloadOverlapCheck = 1 << 5,
+
     // For function types, skip the return type check.
-    SkipFunctionReturnTypeCheck = 1 << 5,
+    SkipFunctionReturnTypeCheck = 1 << 6,
 
     // Allow bool values to be assigned to TypeGuard[x] types.
-    AllowBoolTypeGuard = 1 << 6,
+    AllowBoolTypeGuard = 1 << 7,
 
     // In most cases, literals are stripped when assigning to a
     // type variable. This overrides the standard behavior.
-    RetainLiteralsForTypeVar = 1 << 7,
+    RetainLiteralsForTypeVar = 1 << 8,
 
     // When validating the type of a self or cls parameter, allow
     // a type mismatch. This is used in overload consistency validation
     // because overloads can provide explicit type annotations for self
     // or cls.
-    SkipSelfClsTypeCheck = 1 << 8,
+    SkipSelfClsTypeCheck = 1 << 9,
 
     // If an assignment is made to a TypeVar that is out of scope,
     // do not generate an error. This is used for populating the
     // typeVarContext when handling contravariant parameters in a callable.
-    IgnoreTypeVarScope = 1 << 9,
+    IgnoreTypeVarScope = 1 << 10,
 
     // We're initially populating the typeVarContext with an expected type,
     // so TypeVars should match the specified type exactly rather than
     // employing narrowing or widening, and don't strip literals.
-    PopulatingExpectedType = 1 << 10,
+    PopulatingExpectedType = 1 << 11,
 
     // Used with PopulatingExpectedType, this flag indicates that a TypeVar
     // constraint that is Unknown should be ignored.
-    SkipPopulateUnknownExpectedType = 1 << 11,
+    SkipPopulateUnknownExpectedType = 1 << 12,
 
     // Normally, when a class type is assigned to a TypeVar and that class
     // hasn't previously been specialized, it will be specialized with
     // default type arguments (typically "Unknown"). This flag skips
     // this step.
-    AllowUnspecifiedTypeArguments = 1 << 12,
+    AllowUnspecifiedTypeArguments = 1 << 13,
 
     // PEP 544 says that if the dest type is a type[Proto] class,
     // the source must be a "concrete" (non-protocol) class. This
     // flag skips this check.
-    IgnoreProtocolAssignmentCheck = 1 << 13,
+    IgnoreProtocolAssignmentCheck = 1 << 14,
 }
 
 export interface ApplyTypeVarOptions {

packages/pyright-internal/src/tests/samples/overload5.py

@@ -365,3 +365,32 @@ def func20(choices: AllStr) -> AllStr:
 
 def func20(choices: AllStr) -> AllStr:
     ...
+
+
+# This should generate an overlapping overload error.
+@overload
+def func21(self, p1: int | set[int], /) -> str:
+    ...
+
+
+@overload
+def func21(self, p1: int | list[int], /) -> int:
+    ...
+
+
+def func21(self, p1: int | set[int] | list[int], /) -> str | int:
+    return ""
+
+
+@overload
+def func22(self, p1: str | set[int], /) -> str:
+    ...
+
+
+@overload
+def func22(self, p1: int | list[int], /) -> int:
+    ...
+
+
+def func22(self, p1: str | int | set[int] | list[int], /) -> str | int:
+    return ""

packages/pyright-internal/src/tests/typeEvaluator4.test.ts

@@ -297,7 +297,7 @@ test('Overload5', () => {
 
     configOptions.diagnosticRuleSet.reportOverlappingOverload = 'error';
     analysisResults = TestUtils.typeAnalyzeSampleFiles(['overload5.py'], configOptions);
-    TestUtils.validateResults(analysisResults, 11);
+    TestUtils.validateResults(analysisResults, 12);
 });
 
 test('Overload6', () => {