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