Redirecting factory constructors should allow generics

[Zekfad]

When redirecting non-generic class to generic implementation you always lose generic argument.
Example:

sealed class Size {
  const Size();
  const factory Size.static(int size) = StaticSize;
  /// possible
  const factory Size.dynamic(ValueElement element) = DynamicSize;
  /// desired
  const factory Size.dynamic2<T extends ValueElement>(T element) = DynamicSize<T>;

  /// possible as method, but it's not a constructor and __not const__
  static Size dynamic3<T extends ValueElement>(T element) => DynamicSize<T>(element);
  int get size;
}

final class StaticSize implements Size {
  const StaticSize(this.size);

  @override
  final int size;
}

final class DynamicSize<T extends ValueElement> implements Size {
  const DynamicSize(this.element);

  final T element;

  @override
  int get size => element.asInt;
}

About instantiation, you can't call constructor like const Size<T>.dynamic(value) because Size have no argument and that's ok, but you can do const Size.dynamic<T>(value) if it's static method, but not a constructor.

It would be nice to have an exception for redirecting constructors to have generics, because that would allow better usage of const factory.

[lrhn]

The issue here is the constructors cannot have type arguments, they can only depend on the type arguments of the class itself.
The existing request for having separate type arguments for the constructor itself is #647.
It's not just useful for factory constructors.

In this particular case, where the class itself has no type arguments, I'd probably just change the factory constructor to be a static function.

[Zekfad]

Thank you for answer, that approach loses const, but it will work for my use case.

You can place this example as another argument to the provided issue.