Assignability of generic type `Never`

[SandroMaglione]

I noticed that the Never type seems to be assignable to any other type when working with generics:

class Obj<A> {
  const Obj();
}

final val = Obj<Never>();

void fun(Obj<String> obj) {}

void main() {
  fun(val); // 👈 No error here when Obj<Never> passed to Obj<String>
}

I would expect calling fun with val to error at compile time, since Obj<Never> cannot be assigned to Obj<String>.

In my specific case I am using Never to express a "missing"/"not possible" value (reference), and this breaks at compile time in cases like below:

class Obj<A> {
  const Obj();
  
  void execute(A a) {}
}

final val = Obj<Never>();

void fun(Obj<String> obj) {
  obj.execute("abc"); // 👈 `String` not `Never`
}

void main() {
  fun(val);
}

Is this the correct/expected behaviour?

Note: In my usecase would void be preferable to Never?

[mateusfccp]

Never is the bottom type, which means Obj<Never> <: Obj<String>.

In a static analysis, it's completely valid to pass a value of type Never to any place that requires T, being T any other type (in your example, String).

The only problem is that, in practice, it's not possible to create a value of type Never. The only expression, AFAIK, that inherently has a static type Never is a throw expression. You can also make a function that always throws return Never.

Thus, it seems it's working perfectly as expected.

Ps. I tried your second code and it does not break at compile time, but at runtime.

[mateusfccp]

In my usecase would void be preferable to Never?

I am not sure what you are trying to achieve (I didn't read the entire code). In your second sample code, by using void you would get the static analysis to tell you that, obviously, Obj<void> is not a subtype of Obj<String>. However, the semantics are the completely opposite of Never, so I don't know if this is what you want.

void is one of the top types of Dart (just like Object? and dynamic). So, for example, a List<void> can receive any object, just like a List<Object?>. The only difference is that void conveys the semantics of "the type of this value is irrelevant" or "the value is unused", so the static analysis imposes some additional constraints that, in general, disallow using a "void value".

void main() {
  final list = <void>[1, 'String'];
  print('First value: ${list[0]}'); // Compile-time error: this expression has a type of 'void' so its value can't be used.
}

[lrhn]

What @mateusfccp says, Never is the bottom type, it's deliberately a subtype of all types.

Your problem isn't Never, it's covariant generics. Your method Object<A>.execute uses the type parameter A contravariantly, but Obj<A> is covariant in A.

That means that Obj<String> o = Obj<Never>(); is allowed, but then doing o.execute("a string") is unsafe and throws at runtime.

That's not just about never.
Doing Obj<Object> o = Obj<String>(); is also valid, and doing o.execute(87) will also throw.
Precisely like List<Object> l = <String>[]; l.add(87);.

So this is all working as intended, and until Dart gets a way to make class type parameters contravariant, is just something to be careful around.

[SandroMaglione]

@lrhn should I look at #524 for type parameters variance in dart? Is the dart team planning to work on it in the near future?

[lrhn]

Yes, #524 is the issue for variance annotations.
The language team is always planning to work on that, it just tends to never be the highest priority.

[SandroMaglione]

@lrhn is it possible to check if a generic type is Never?

In my usecase dart is inferring generic types as Never, which causes cryptic runtime errors for users of the library. The problem is that since Never is "assignable" to everything, I cannot place checks on the generic type.

Any suggestions on how to prevent this?