Generic type inference doesn't work when extending nullable type

[HosseinYousefi]

This works fine:

class Foo {}

class Bar<T extends Foo?> {
  final T foo;
  Bar(this.foo);
  
  static Bar<T> bar<T extends Foo>(T foo) {
    return Bar(foo); // <-- No need to write Bar<T>(foo)
  }
}

but if T extends Foo? instead, it doesn't:

class Foo {}

class Bar<T extends Foo?> {
  final T foo;
  Bar(this.foo);
  
  static Bar<T> bar<T extends Foo?>(T foo) {
    return Bar(foo);
    //         ^^^
    // The argument type 'T' can't be assigned to the parameter type 'Never'.
  }
}

Is this expected behavior?

[dart-github-bot]

Summary: The issue reports that generic type inference fails when a type parameter T extends a nullable type (Foo?) in a static method. The code compiles when T extends a non-nullable type (Foo), but throws an error when T extends a nullable type.

[eernstg]

Related to #56998?

[johnniwinther]

I don't think it's related. @chloestefantsova can you take a look?

[lrhn]

Looks like a bug, or a very undeseriable property of inference.

The return Bar(foo); should infer return Bar<T>(foo); from the context type (return type of function is Bar<T>), and then foo is a valid argument.
If you write return Bar<T>(foo); it works. For some reason inference fails to do the obvious thing with a context type of Bar<T>, and infers Bar<Never>(foo) instead.

[johnniwinther]

@chloestefantsova Have you had a chance to look at this?

[chloestefantsova]

Yes, sorry for the delayed response here. It looks like it's an undesirable property of inference, like @lrhn mentioned. More precisely, it's an undesirable property of the lower bound algorithm that yields Never as the lower bound of X extends A? and A?.

The following is the rough outline of what happens:

1. The type parameter Bar.T is constrained by Bar.bar.T as a result of the constraint gathering (see https://github.com/dart-lang/language/blob/main/resources/type-system/inference.md#subtype-constraint-generation). So far so good: this is exactly what we intuitively want.
2. Since the solution of the constraints for Bar.T doesn't contain the unknown type (_), it's almost ready to be declared the preliminary inference result for that variable. As the final step, we need to check if adding the bound as the constraint won't yield a better result (see https://github.com/dart-lang/language/blob/main/resources/type-system/inference.md#constraint-solution-for-a-set-of-type-variables).
3. Adding the bound means merging two type constraints: Bar.T <# Bar.bar.T and Bar.T <# Foo?. Since both constraints are constraints from above, merging them means computing their lower bound.
4. The lower bound algorithm, as described in https://github.com/dart-lang/language/blob/main/resources/type-system/upper-lower-bounds.md#lower-bounds, will match the pair of types Bar.bar.T and Foo? and execute the step DOWN(T1, T2?) = S where S is DOWN(T1, T2), removing the ? from Foo?.
5. Finally, the lower bound algorithm yields Never for the pair of types Bar.bar.T and Foo.

This is very unfortunate, since the actual greatest lower bound for Bar.bar.T and Foo? is Bar.bar.T, but the algorithm produces Never as its best effort.

Note that in the first example that doesn't happen because in that case the lower bound algorithm compares two types of the form X extends A, A?, and DOWN(X extends A, A?) = DOWN(X extends A, A) = X.

@eernstg WDYT?