Bounds on generic methods should be treated invariantly in subtyping

[leafpetersen]

Currently, the analyzer treats generic method bounds contra-variantly for sub-typing purposes. For example, the following is allowed:

class A {
  void foo<T extends num>() {}
}

class B extends A {
  void foo<T extends Object>() {}
}

Per language team decision, this should be changed to require that bounds be equal.

[MichaelRFairhurst]

Clarification, does this affect function subtyping in general?

Function<T extends num>() fn = <T extends int>(){};

It seems like this is already an error, so I'm assuming this is truly limited to method overrides.

[MichaelRFairhurst]

this is also currently not an error:

class C extends A {                                                              
  void foo<T>() {                                                                
    return foo<String>();                                                        
  }                                                                              
}

Would the error be at override, or would it infer the type parameter to have a bound, in which case the error would be at the type application site of foo?

@leafpetersen for these questions

[MichaelRFairhurst]

Oops, had tested contravariance before. Function type's type parameters are currently covariant inside the type system, should that change too?

Function<T extends num>() fn = <T extends int>(){}; // OK

[leafpetersen]

@MichaelRFairhurst I'm confused about the results you claim to see above. Just tested with bleeding edge analyzer and I see covariance as an error, contra-variance currently ok:

void main() {
  Function<T extends num>() fn = <T extends int>(){}; // Error
  Function<T extends int>() fn2 = <T extends num>(){}; // Currently OK, should be error.
}

The contra-variant case should also be an error.

This applies to all places that subtype checking is done (override, assignment, etc).

This example:

class C extends A {                                                              
  void foo<T>() {                                                                
    return foo<String>();                                                        
  }                                                                              
}

I don't understand. There is no subtype checking involved here? In any case, this is valid code: Dart has polymorphic recursion.