[cfe/analyzer] No error when extension type Type is duplicated with its underlying type's in constant sets and maps

[parlough]

Currently the following passes analysis and compiles, but I think it shouldn't since at runtime E and int are equal and const sets/maps don't allow elements/keys that are equal. I haven't read the full extension type spec though, so I might be missing something :)

Currently compiling and passing analysis:

extension type E(int value) {}

const testSet = {int, E};
const testMap = {int: 1, E: 2};

Expected:

const testSet = {int, E}; // error: equal_elements_in_const_set
const testMap = {int: 1, E: 2}; // error: equal_keys_in_const_map

Dart SDK version: 3.3.0-edge.8b3d93234d1df69c3db5428fa02bb6b39c671ed8

[bwilkerson]

@eernstg Is the instance of Type represented by int the same as the instance of Type represented by E in the example above?

[eernstg]

Yes, the run-time representation of an extension type is the 'extension type erasure' (sometimes known as the ultimate representation type), and in this case it's int, so identical(E, int) is true and the errors are fine.

[eernstg]

(It's surprising that those errors aren't reported: I thought such things as "duplicate element in constant set" were checked based on the a static-analysis stand-in for the object which is the result of a constant evaluation, and that would be the Type for int in both cases, so there wouldn't have to be any new actions in order to determine that it's a duplication.)

[bwilkerson]

@scheglov @kallentu

My guess is that we either haven't implemented constant evaluation for extension types or we've failed to reduce the type to the extension type erasure before creating the representation of DartObject for that type.

[lrhn]

Constant evaluation with extension types is somewhat special in that it should use the runtime semantics, which have erased extension types, but every result can still have a static type which is an extension type.
Pure runtime evaluation can completely forget extension types, but constant evaluation has to move back and forth between the static type system and the runtime type system.

That is: We need tests. Lots of tests.

[lrhn]

I'm working on "tests, lots of tests", and while they're not complete yet, and probably not all correct yet, I am seeing similar issues when directly comparing constant type expressions for identity.

https://dart-review.googlesource.com/c/sdk/+/335560/2/tests/language/extension_type/constant_computation_test.dart

[scheglov]

https://dart-review.googlesource.com/c/sdk/+/336501