spec/conformance: function with TypeVar default and default argument used in context.

[randolf-scholz]

I want to suggest adding the following test to the conformance test suite:

class Getter[T]:
    def get[S=None](self, default: S = None) -> T | S: ...  # OK

def test(arg: Getter[str]) -> None:
    result: str = arg.get()  # type: ignore

• Since the default argument value is assignable to the default type var type, def get is well-defined
• arg.get() implicitly uses None of type None as the argument. Therefore, we have an implicit constraint S <: None when .get is called without explicit default.

Therefore, result: str = arg.get() should raise an assignment type error (str | None not assignalbe to str).

Currently, only pyright succeeds on this test, and type checker results diverge.

1. pyright: no errors (true negative on def get, true positive on result) (pyright playground)
2. mypy: false positive on def get, false negative on result.
3. ty: false positive on def get, true positive on result. (playground)
4. pyrefly: false positive on def get, false negative on result (playground)
5. zuban: false postive on def get, false negative on result.

Related Issues

• Unable to specify a default value for a generic parameter mypy#3737 (one of the most upvotes issues on mypy)
• invalid-parameter-default error from generic with default of None astral-sh/ty#592

[JelleZijlstra]

The semantics of TypeVar defaults on generic functions are explicitly unspecified (https://typing.python.org/en/latest/spec/generics.html#function-defaults), so adding this case would require a spec change. Your use case seems reasonable though!

I'd write the test case with assert_type(arg.get(), str | None).

[randolf-scholz]

@JelleZijlstra

I'd write the test case with assert_type(arg.get(), str | None).

Well, actually all type checkers succeed for this case, the problem is that with the outer context str, checkers like mypy forget about the S <: None constraints when no explicit default is given, and happily present S=str as a solution.

Without outer context, the default S=None is used instead.

[randolf-scholz]

So the spec I am essentially arguing for here for is:

1. If a function parameter is annotated with a type-variable with a default, then the default argument for that parameter must be assignable to that type var default.

   def get[T = object](default: T = object()) -> T: ...  # OK, object() is assignable to object
   def get[T = object](default: T = "123") -> T: ...  # Also OK, "123" is assignable to object
   def get[T = str](default: T = None) -> T: ...  # E: None is not assignable to str

2. If for a parameter annotated with a TypeVar with default, no arguments are provided in a function call, then this should be treated as-if an argument of the default type were provided

   def get[T = None](default: T = None) -> T: ...
   
   get()  # identical inferenence as get(None)
   
   def get[T = object](default: T = None) -> T: ...
   
   get()  # identical inference as get( object() ), although real default is None

In particular in my original example, both result: str = arg.get() and result: str = arg.get(default=None) should give identical inference.