Turning reified types into legacy types for constant expressions

[eernstg]

Thanks to @fishythefish for noting this. Consider the following program:

typedef T = int? Function();
const t = T;

void main() {
  print(T);
  print(t);
}

This prints () => int? and () => int with dart --enable-experiment=non-nullable --no-null-safety from c800b8d.

However, https://github.com/dart-lang/language/blob/master/accepted/future-releases/nnbd/feature-specification.md#const-evaluation-and-canonicalization only specifies that type arguments passed to collection literals and constant object expressions should be turned into legacy types in weak checking mode, but the above doesn't include any type arguments, and there does not seem to be a rule that turns function types into legacy types for constant expressions.

[fishythefish]

Thanks, Erik. This originally came up when I was investigating the test failure here: https://dart-review.googlesource.com/c/sdk/+/150680

In fact, dart2js prints () => int for T as well, since we also call the CFE constant evaluator on expressions we know to be effectively constant even if they're not literally const. (This is why the failure only shows up on the dart2js bot in the linked CL.)

convertType seems to be responsible here:

sdk/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart

Lines 1066 to 1070 in c800b8d

	@override
	Constant visitTypeLiteral(TypeLiteral node) {
	final DartType type = evaluateDartType(node, convertType(node.type));
	return canonicalize(new TypeLiteralConstant(type));
	}

/cc @nshahan

[eernstg]

In fact, dart2js prints () => int for T as well

Yes, I just noticed that. ;)

Checking the kernel code — the following program translates as shown below:

int? f() => null;
typedef T = int? Function();
const t = T;

void main() {
  print(f.runtimeType);
  print(T);
  print(t);
}

library /*isNonNullableByDefault*/;
import self as self;
import "dart:core" as core;

typedef T = () → core::int?;
static const field core::Type t = #C1;
static method f() → core::int?
  return null;
static method main() → void {
  core::print((#C2).{core::Object::runtimeType});
  core::print(() → core::int?);
  core::print(#C1);
}
constants  {
  #C1 = TypeLiteralConstant(() →* core::int*)
  #C2 = tearoff self::f
}

So this means that there is a CFE element of this behavior: It converts the typedef into a legacy type for the initialization of the constant variable, but leaves the typedef itself as a type with nullability.

[fishythefish]

IMO, we should update the CFE to match what's currently in the spec and only perform the legacy erasure where needed to improve canonicalization.

Tentative fix: https://dart-review.googlesource.com/c/sdk/+/150821

[alexmarkov]

@crelier VM also applies legacy erasure to core libraries when loading them from agnostic platform dill file in weak mode. Do we need to avoid applying legacy erasure when handling kTypeLiteralConstant in ConstantReader::ReadConstantInternal ?

[crelier]

@alexmarkov We indeed apply legacy erasure to type literals, which, according to this report is wrong.
I'll send a CL. Thanks for noticing.

[crelier]

VM fix: https://dart-review.googlesource.com/c/sdk/+/151020