Unable to infer closure parameter type

[Taoduhui]

typedef CallbackA<T extends MyClassBase> = void Function(MyClassB<T> s);

abstract class MyClassBase{

}

class MyClassA<T> extends MyClassBase{
  T value;

  MyClassA({
    required this.value,
    List<CallbackA<MyClassA<T>>> callbacks = const [],
  });
}

class MyClassB<T extends MyClassBase> {}

var a = MyClassA(
  value: 1,
  callbacks:[
    (c /* MyClassB<MyClassA<Object?>> */){
      
    }
  ] // List<void Function(MyClassB<MyClassA<int>>)>
);

var b = MyClassA<int>(
  value: 1,
  callbacks:[
    (c /* MyClassB<MyClassA<int>> */){
      
    }
  ] // List<void Function(MyClassB<MyClassA<int>>)>
);

In scenario a, the callback parameter is inferred as Object?, even though the callbacks property has the correct type.

the correct type can be inferred if the generic type for MyClassA is explicitly declared.

[lrhn]

I think something weird is going on there.

The analyzer infers Object?, the CFE (DDC in DartPad, main channel) infers int. Or maybe it doesn't, just something that looks like int.

If I instrument the example to print the static type of c and the closure, it prints MyClassB<MyClassA<int>> as the parameter/argument type.
If I try to use the static-type-checker extension function on the value, it claims to not be equivalent to MyClassB<MyClassA<int>>.

Just doing int v = c; gives two errors, as if c has two different types and neither are assignable to int.
Which also suggests being analyzed more than once, with different results.

typedef CallbackA<T extends MyClassBase> = void Function(MyClassB<T> s);

abstract class MyClassBase{}

class MyClassA<T> extends MyClassBase{
  T value;

  MyClassA({
    required this.value,
    List<void Function(MyClassB<MyClassA<T>>)> callbacks = const [],
  }) {
    callbacks.first(MyClassB<Never>()); // Run it.
  }
}

class MyClassB<T extends MyClassBase> {}

var a = MyClassA(
  value: 1,
  callbacks:[
    (c /* MyClassB<MyClassA<Object?>> */){
      // c.st<E<MyClassB<MyClassA<Object?>>>>(); // OK analyzer, not OK DDC
      c.logStaticType; //DDC: MyClassB<MyClassA<int>>
      print([c].runtimeType); //DDC: List<MyClassB<MyClassA<int>>>
      print(c.staticType == MyClassB<MyClassA<int>>); //DDC: true
      // c.st<E<MyClassB<MyClassA<int>>>>(); // err Analyzer and DDC
      
      // int v = c; //DDC: Two errors
      //:A value of type 'MyClassB<MyClassA<Object?>>' can't be assigned to a variable of type 'int'.
      //:A value of type 'MyClassB<MyClassA<int>>' can't be assigned to a variable of type 'int'.
    }
     ..logStaticType //: (MyClassB<MyClassA<int>>) => void
     // ..st<E<void Function(MyClassB<MyClassA<Object?>>)>>() // OK Analyzer, err DDC
     // ..st<E<void Function(MyClassB<MyClassA<int>>)>>() // err Analyzer and DDC
  ] // List<void Function(MyClassB<MyClassA<int>>)>
);

var b = MyClassA<int>(
  value: 1,
  callbacks:[
    (c /* MyClassB<MyClassA<int>> */){
      c..st<E<MyClassB<MyClassA<int>>>>();
    }..st<E<void Function(MyClassB<MyClassA<int>>)>>()
  ] // List<void Function(MyClassB<MyClassA<int>>)>
);

void main(){
  a;
}

extension <T> on T {
  Type get staticType => T;
  void st<X extends E<T>>(){}
  void get logStaticType {
    print("$T");
  }
}
typedef E<T> = T Function(T);

[johnniwinther]

cc @chloestefantsova @stereotype441

[eernstg]

The most surprising part is probably that the parameter c is considered to have type dynamic in the body of the function literal, but the function literal is compiled with the type void Function(C<B<int>>), and the list with type List<void Function(C<B<int>>)>. Perhaps the type of the parameter in the function literal isn't initialized properly?

With some simplifications, we get this example (which is analyzed by the CFE with no errors, and executed with no run-time failures, and demonstrates a soundness violation):

// Observation.

typedef Exactly<X> = X Function(X);

extension<X> on X {
  X expectStaticType<Y extends Exactly<X>>() => this;
}

// Example.

abstract class A {}

class B<T> extends A {
  T value;  
  List<void Function(C<B<T>>)> callbacks;
  B({required this.value, this.callbacks = const []}) {
    print(callbacks.runtimeType); // 'List<(C<B<int>>) => void>'.
    print(callbacks[0].runtimeType); // '(C<B<int>>) => void'.
  }
}

class C<T extends A> {}

var a = B(
  value: 1,
  callbacks: [(c) { bool _ = c; /*`c` has type `dynamic`*/ }]
)..expectStaticType<Exactly<B<int>>>();

void main() {
  a.callbacks[0]..expectStaticType<Exactly<void Function(C<B<int>>)>>();
  (a.callbacks[0] as Function)(C<B<int>>());
}