Callable class generic type not inferred from context

[arthurbcd]

Dart does not infer the generic type of a callable class from the context, even when the type is unambiguous. For example:

class Validator<T> {
  String? call(T? value) => null;
}

TextFormField(validator: Validator()); // T inferred as dynamic (dart 3.10.1)

• TextFormField.validator expects String? Function(String?).
• Declaring Validator() works, but is redundant, because any other type produces a compile-time error.
• In theory, the compiler could infer T = String automatically, since it’s the only valid choice.
• Dart already does this inference for closures, but not for callable classes.

This would make callable classes more ergonomic in situations like this.

Is this behavior intended? Why?
Could Dart support inferring the generic type of a callable class from the context?

[lrhn]

Yes, it's intended.

Maybe we can do better, but the current inference specification doesn't.

The context type of String? Function(String?) does not constrain the type parameter of Validator() by itself. Downwards inference does not look at the type of call of the type being created. It doesn't know that it should.

Coercion from callable object to function happens after type inference of Validator(), at which point it has been inferred as Validator<dynamic>().

To do better, downwards inference would need to be coercion aware:

• If the context type of an expression is a function type, and the uninstantiated type being compared to that function type has a call method, try doing downwards inference against the function type of the call method instead, then lift the result back as type arguments to the expression.
• Which gets even more complicated if it also has to consider implicit instantiation of a generic function, if the call method is generic and the context type isn't.

@stereotype441