[cfe] Handle unevaluated constants in enums for exhaustiveness checking

If enum values have used defined fields that use fromEnvironment constants
the enum values themselves are seen as unevaluated constants when
compiling with dart2js. This means that the enum value are not recognized
correctly in exhaustiveness checking.

This CL changes the enum value representation of the CFE to use the
enum class and the name of the enum element, derived either from the
instance constant or the unevaluated constant expression.

Change-Id: I7d5791a41349dacd20b588f5dbfca37d8755ef79
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/299100
Commit-Queue: Johnni Winther <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>

Author: johnniwinther

pkg/front_end/lib/src/fasta/kernel/exhaustiveness.dart

@@ -246,8 +246,47 @@ class CfeTypeOperations implements TypeOperations<DartType> {
   }
 }
 
+class EnumValue {
+  final Class enumClass;
+  final String name;
+
+  EnumValue(this.enumClass, this.name);
+
+  @override
+  int get hashCode => Object.hash(enumClass, name);
+
+  @override
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    return other is EnumValue &&
+        enumClass == other.enumClass &&
+        name == other.name;
+  }
+}
+
+EnumValue? constantToEnumValue(CoreTypes coreTypes, Constant constant) {
+  if (constant is InstanceConstant && constant.classNode.isEnum) {
+    StringConstant name = constant
+        .fieldValues[coreTypes.enumNameField.fieldReference] as StringConstant;
+    return new EnumValue(constant.classNode, name.value);
+  } else if (constant is UnevaluatedConstant) {
+    Expression expression = constant.expression;
+    if (expression is FileUriExpression) {
+      expression = expression.expression;
+    }
+    if (expression is InstanceCreation && expression.classNode.isEnum) {
+      ConstantExpression name =
+          expression.fieldValues[coreTypes.enumNameField.fieldReference]
+              as ConstantExpression;
+      return new EnumValue(
+          expression.classNode, (name.constant as StringConstant).value);
+    }
+  }
+  return null;
+}
+
 class CfeEnumOperations
-    implements EnumOperations<DartType, Class, Field, Constant> {
+    implements EnumOperations<DartType, Class, Field, EnumValue> {
   final ConstantEvaluator _constantEvaluator;
 
   CfeEnumOperations(this._constantEvaluator);
@@ -271,7 +310,7 @@ class CfeEnumOperations
   }
 
   @override
-  Constant getEnumElementValue(Field enumField) {
+  EnumValue getEnumElementValue(Field enumField) {
     // Enum field initializers might not have been replaced by
     // [ConstantExpression]s. Either because we haven't visited them yet during
     // normal constant evaluation or because they are from outlines that are
@@ -280,7 +319,8 @@ class CfeEnumOperations
     // enum element.
     StaticTypeContext context =
         new StaticTypeContext(enumField, _constantEvaluator.typeEnvironment);
-    return _constantEvaluator.evaluate(context, enumField.initializer!);
+    return constantToEnumValue(_constantEvaluator.coreTypes,
+        _constantEvaluator.evaluate(context, enumField.initializer!))!;
   }
 
   @override
@@ -394,7 +434,7 @@ class CfeSealedClassOperations
 }
 
 class CfeExhaustivenessCache
-    extends ExhaustivenessCache<DartType, Class, Class, Field, Constant> {
+    extends ExhaustivenessCache<DartType, Class, Class, Field, EnumValue> {
   final TypeEnvironment typeEnvironment;
 
   CfeExhaustivenessCache(
@@ -527,13 +567,15 @@ class PatternConverter with SpaceCreator<Pattern, DartType> {
 
   Space convertConstantToSpace(Constant? constant, {required Path path}) {
     if (constant != null) {
-      if (constant is NullConstant) {
+      EnumValue? enumValue =
+          constantToEnumValue(cache.typeEnvironment.coreTypes, constant);
+      if (enumValue != null) {
+        return new Space(path,
+            cache.getEnumElementStaticType(enumValue.enumClass, enumValue));
+      } else if (constant is NullConstant) {
         return new Space(path, StaticType.nullType);
       } else if (constant is BoolConstant) {
         return new Space(path, cache.getBoolValueStaticType(constant.value));
-      } else if (constant is InstanceConstant && constant.classNode.isEnum) {
-        return new Space(
-            path, cache.getEnumElementStaticType(constant.classNode, constant));
       } else if (constant is RecordConstant) {
         Map<Key, Space> properties = {};
         for (int index = 0; index < constant.positional.length; index++) {

pkg/front_end/testcases/dart2js/enum_from_environment.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+enum A {
+  a(B.a),
+  b(B.b),
+  ;
+
+  final B value;
+
+  const A(this.value);
+}
+
+class B {
+  final int value;
+
+  const B(this.value);
+
+  static const B a = const B(const int.fromEnvironment('a'));
+  static const B b = const B(const int.fromEnvironment('b'));
+}
+
+String method(A a) {
+  switch (a) {
+    case A.a:
+      return 'a';
+    case A.b:
+      return 'b';
+  }
+}

pkg/front_end/testcases/dart2js/enum_from_environment.dart.strong.expect

@@ -0,0 +1,66 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::A> values = #C13;
+  final field self::B value;
+  enum-element static const field self::A a = #C5;
+  enum-element static const field self::A b = #C11;
+  const constructor •(core::int #index, core::String #name, self::B value) → self::A
+    : self::A::value = value, super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "A.${this.{core::_Enum::_name}{core::String}}";
+  static method _#new#tearOff(core::int #index, core::String #name, self::B value) → self::A
+    return new self::A::•(#index, #name, value);
+}
+class B extends core::Object /*hasConstConstructor*/  {
+  final field core::int value;
+  static const field self::B a = #C3;
+  static const field self::B b = #C9;
+  const constructor •(core::int value) → self::B
+    : self::B::value = value, super core::Object::•()
+    ;
+  static method _#new#tearOff(core::int value) → self::B
+    return new self::B::•(value);
+}
+static method method(self::A a) → core::String {
+  #L1:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C5:
+      {
+        return "a";
+      }
+    #L3:
+    case #C11:
+      {
+        return "b";
+      }
+  }
+}
+
+constants  {
+  #C1 = "a"
+  #C2 = eval const core::int::fromEnvironment(#C1)
+  #C3 = eval self::B{value:#C2}
+  #C4 = 0.0
+  #C5 = eval self::A{value:#C3, index:#C4, _name:#C1}
+  #C6 = eval const <dynamic>[#C5]
+  #C7 = "b"
+  #C8 = eval const core::int::fromEnvironment(#C7)
+  #C9 = eval self::B{value:#C8}
+  #C10 = 1.0
+  #C11 = eval self::A{value:#C9, index:#C10, _name:#C7}
+  #C12 = eval const <dynamic>[#C11]
+  #C13 = eval #C6 + #C12
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///enum_from_environment.dart:
+- B. (from org-dartlang-testcase:///enum_from_environment.dart:18:9)
+- Object. (from org-dartlang-sdk:///lib/core/object.dart)
+- A. (from org-dartlang-testcase:///enum_from_environment.dart:12:9)
+- _Enum. (from org-dartlang-sdk:///lib/core/enum.dart)

pkg/front_end/testcases/dart2js/enum_from_environment.dart.strong.transformed.expect

@@ -0,0 +1,76 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::A> values = #C13;
+  final field self::B value;
+  enum-element static const field self::A a = #C5;
+  enum-element static const field self::A b = #C11;
+  const constructor •(core::int #index, core::String #name, self::B value) → self::A
+    : self::A::value = value, super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "A.${this.{core::_Enum::_name}{core::String}}";
+  static method _#new#tearOff(core::int #index, core::String #name, self::B value) → self::A
+    return new self::A::•(#index, #name, value);
+}
+class B extends core::Object /*hasConstConstructor*/  {
+  final field core::int value;
+  static const field self::B a = #C3;
+  static const field self::B b = #C9;
+  const constructor •(core::int value) → self::B
+    : self::B::value = value, super core::Object::•()
+    ;
+  static method _#new#tearOff(core::int value) → self::B
+    return new self::B::•(value);
+}
+static method method(self::A a) → core::String {
+  #L1:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C5:
+      {
+        return "a";
+      }
+    #L3:
+    case #C11:
+      {
+        return "b";
+      }
+  }
+}
+
+constants  {
+  #C1 = "a"
+  #C2 = eval const core::int::fromEnvironment(#C1)
+  #C3 = eval self::B{value:#C2}
+  #C4 = 0.0
+  #C5 = eval self::A{value:#C3, index:#C4, _name:#C1}
+  #C6 = eval const <dynamic>[#C5]
+  #C7 = "b"
+  #C8 = eval const core::int::fromEnvironment(#C7)
+  #C9 = eval self::B{value:#C8}
+  #C10 = 1.0
+  #C11 = eval self::A{value:#C9, index:#C10, _name:#C7}
+  #C12 = eval const <dynamic>[#C11]
+  #C13 = eval #C6 + #C12
+}
+
+Extra constant evaluation status:
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:5:6 -> ListConstant(const <A>[const A{A.value: const B{B.value: 0.0}, _Enum.index: 0.0, _Enum._name: "a"}, const A{A.value: const B{B.value: 0.0}, _Enum.index: 1.0, _Enum._name: "b"}])
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:6:3 -> InstanceConstant(const A{A.value: const B{B.value: 0.0}, _Enum.index: 0.0, _Enum._name: "a"})
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:7:3 -> InstanceConstant(const A{A.value: const B{B.value: 0.0}, _Enum.index: 1.0, _Enum._name: "b"})
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:20:28 -> InstanceConstant(const B{B.value: 0.0})
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:21:28 -> InstanceConstant(const B{B.value: 0.0})
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:26:12 -> InstanceConstant(const A{A.value: const B{B.value: 0.0}, _Enum.index: 0.0, _Enum._name: "a"})
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///enum_from_environment.dart:28:12 -> InstanceConstant(const A{A.value: const B{B.value: 0.0}, _Enum.index: 1.0, _Enum._name: "b"})
+Extra constant evaluation: evaluated: 21, effectively constant: 7
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///enum_from_environment.dart:
+- B. (from org-dartlang-testcase:///enum_from_environment.dart:18:9)
+- Object. (from org-dartlang-sdk:///lib/core/object.dart)
+- A. (from org-dartlang-testcase:///enum_from_environment.dart:12:9)
+- _Enum. (from org-dartlang-sdk:///lib/core/enum.dart)

pkg/front_end/testcases/dart2js/enum_from_environment.dart.textual_outline.expect

@@ -0,0 +1,17 @@
+enum A {
+  a(B.a),
+  b(B.b),
+  ;
+
+  final B value;
+  const A(this.value);
+}
+
+class B {
+  final int value;
+  const B(this.value);
+  static const B a = const B(const int.fromEnvironment('a'));
+  static const B b = const B(const int.fromEnvironment('b'));
+}
+
+String method(A a) {}

pkg/front_end/testcases/dart2js/enum_from_environment.dart.textual_outline_modelled.expect

@@ -0,0 +1,17 @@
+String method(A a) {}
+
+class B {
+  const B(this.value);
+  final int value;
+  static const B a = const B(const int.fromEnvironment('a'));
+  static const B b = const B(const int.fromEnvironment('b'));
+}
+
+enum A {
+  a(B.a),
+  b(B.b),
+  ;
+
+  final B value;
+  const A(this.value);
+}

pkg/front_end/testcases/dart2js/enum_from_environment.dart.weak.expect

@@ -0,0 +1,70 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+class A extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::A> values = #C13;
+  final field self::B value;
+  enum-element static const field self::A a = #C5;
+  enum-element static const field self::A b = #C11;
+  const constructor •(core::int #index, core::String #name, self::B value) → self::A
+    : self::A::value = value, super core::_Enum::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "A.${this.{core::_Enum::_name}{core::String}}";
+  static method _#new#tearOff(core::int #index, core::String #name, self::B value) → self::A
+    return new self::A::•(#index, #name, value);
+}
+class B extends core::Object /*hasConstConstructor*/  {
+  final field core::int value;
+  static const field self::B a = #C3;
+  static const field self::B b = #C9;
+  const constructor •(core::int value) → self::B
+    : self::B::value = value, super core::Object::•()
+    ;
+  static method _#new#tearOff(core::int value) → self::B
+    return new self::B::•(value);
+}
+static method method(self::A a) → core::String {
+  #L1:
+  switch(a) /*isExplicitlyExhaustive*/ {
+    #L2:
+    case #C5:
+      {
+        return "a";
+      }
+    #L3:
+    case #C11:
+      {
+        return "b";
+      }
+    #L4:
+    default:
+      throw new _in::ReachabilityError::•("`null` encountered as case in a switch statement with a non-nullable type.");
+  }
+}
+
+constants  {
+  #C1 = "a"
+  #C2 = eval const core::int::fromEnvironment(#C1)
+  #C3 = eval self::B{value:#C2}
+  #C4 = 0.0
+  #C5 = eval self::A{value:#C3, index:#C4, _name:#C1}
+  #C6 = eval const <dynamic>[#C5]
+  #C7 = "b"
+  #C8 = eval const core::int::fromEnvironment(#C7)
+  #C9 = eval self::B{value:#C8}
+  #C10 = 1.0
+  #C11 = eval self::A{value:#C9, index:#C10, _name:#C7}
+  #C12 = eval const <dynamic>[#C11]
+  #C13 = eval #C6 + #C12
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///enum_from_environment.dart:
+- B. (from org-dartlang-testcase:///enum_from_environment.dart:18:9)
+- Object. (from org-dartlang-sdk:///lib/core/object.dart)
+- A. (from org-dartlang-testcase:///enum_from_environment.dart:12:9)
+- _Enum. (from org-dartlang-sdk:///lib/core/enum.dart)