Raw types in bounds should be allowed when the raw type bound is ground

[leafpetersen]

If a parameterized type A is used somewhere in a type bound with no type arguments, it is currently treated as an error in strong mode unless the type parameter to A has no bound. This should be relaxed to also allow this in any case where the bound on the type parameter to A does not reference any other type parameters to A. Examples:

class A<T> {}

/// Already allowed, A is treated as A<dynamic>
class B<T extends A> {}

class C<T extends A<int>> {}

/// Currently disallowed, should be allowed, C is treated as C<A<int>>
class D<T extends C> {}

/// Currently disallowed, should be allowed, List<C> is treated as List<C<A<int>>
class E<T extends List<C>> {}

[mit-mit]

This does not block 1.22; tagging 1.23

[eernstg]

As I argued elsewhere, we should consider treating A as A<Object> rather than A<dynamic>: Allowing dynamic invocation of arbitrary members on expressions whose type is the type argument of A is a non-trivial source of unsoundness, so we may wish to ask programmers to request that explicitly—and write the type they want if they are actually not happy about Object.

[scheglov]

I implemented this change, partially.

There is a problem though. If we allow "instantiate to bounds" for bounds, we cannot resolve bounds in arbitrary order, we need to do this in dependency order. This works with the new analysis driver, because we can resynthesize in any order. But not with the old tasks based analysis. And we're going to remove it in the near future, so I think it is not worth making it work with the old implementation.

[dgrove]

Any updates here?

[scheglov]

I'm working on moving DDC to the new analysis driver, so that we could use resynthesized types.
Once this is done, we will be unblocked to implement this feature only in one place.

[dgrove]

Is this likely to make it for 1.23?