Analyzer ignores type arguments of constants in constant equality checks.

[lrhn]

Example:

void main() {
  const il = <int>[2, 3];
  const nl = <num>[2, 3];
  const v1 = (il == nl) ? (1 ~/ 0) : 0; // Analyzer error
  const v2 = identical(il, nl) ? (1 ~/ 0) : 0;
  
  const iz = <int>{2, 3};
  const nz = <num>{2, 3};
  const v3 = (iz == nz) ? (1 ~/ 0) : 0; // Analyzer error
  const v4 = identical(iz, nz) ? (1 ~/ 0) : 0;
  
  const im = <int, int>{2: 0, 3: 0};
  const nm = <num, int>{2: 0, 3: 0};
  const v5 = (im == nm) ? (1 ~/ 0) : 0; // Analyzer error
  const v6 = identical(im, nm) ? (1 ~/ 0) : 0;

  const ic = C<int>(1);
  const nc = C<num>(1);
  const v7 = (ic == nc) ? (1 ~/ 0) : 0; // Analyzer error
  const v8 = identical(ic, nc) ? (1 ~/ 0) : 0;
}

class C<T> {
  final T v;
  const C(this.v);
}

Here the analyzer considers the constant values equal if they have the same state, but they are not identical, and the types in question do not override Object.operator==, so equality for those objects is identity.

In every example here, the == check should give false.

CFE has no issue.

[lrhn]

And just to make things more fun, here are some more cases:

import "dart:async";
void main() {
  const ln = <Object?>[1];
  const ld = <dynamic>[1];
  const lv = <void>[1];
  const lo = <Object>[1];
  const lfn = <FutureOr<Object?>>[1];
  const lfd = <FutureOr<dynamic>>[1];
  const lfv = <FutureOr<void>>[1];
  const lfo = <FutureOr<Object>>[1];
  const _ = (ln == lv) ? (1 ~/ 0) : 0; // Analyzer fails
  const _ = (ln == ld) ? (1 ~/ 0) : 0; // Analyzer fails
  const _ = (ld == lv) ? (1 ~/ 0) : 0; // Analyzer fails
  const _ = (lfn == lfv) ? (1 ~/ 0) : 0; // Analyzer fails
  const _ = (lfn == lfd) ? (1 ~/ 0) : 0; // Analyzer fails
  const _ = (lfd == lfv) ? (1 ~/ 0) : 0; // Analyzer fails
  const _ = (ln == lfn) ? 0 : (1 ~/ 0); // Equal because NORM(FutureOr<Object?>) = Object?
  const _ = (ld == lfd) ? 0 : (1 ~/ 0); // Equal because NORM(FutureOr<dynamic>) = dynamic
  const _ = (lv == lfv) ? 0 : (1 ~/ 0); // Equal because NORM(FutureOr<void>) = void
  const _ = (lo == lfo) ? 0 : (1 ~/ 0); // Equal because NORM(FutureOr<Object>) = Object
}

It's just the same failure case now, but it's slighlty trickier cases that the fix should also work with.
(It's testing that the type comparison is using NORM'alized types, just like Type.operator==.)

(It's quite possible that the fix is just to use identical for ==, and identical already works correctly, in which there is nothing more to test.)

[srawlins]

These examples are all Lists. But I imagine the problem and the solution is mutatis mutandis for Maps and Sets?