[cfe] Handle NullCheck in constant evaluation

Closes #42802
Closes #42803

Change-Id: I282539cbfef90309dd343950101aefe0820785b7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155600
Reviewed-by: Johnni Winther <johnniwinther@google.com>

Author: johnniwinther

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -1308,6 +1308,14 @@ Message _withArgumentsConstEvalNonConstantVariableGet(String string) {
       arguments: {'string': string});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeConstEvalNonNull = messageConstEvalNonNull;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageConstEvalNonNull = const MessageCode(
+    "ConstEvalNonNull",
+    message: r"""Constant expression must be non-null.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeConstEvalNotListOrSetInSpread =
     messageConstEvalNotListOrSetInSpread;

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

@@ -42,6 +42,7 @@ import '../fasta_codes.dart'
         messageConstEvalFailedAssertion,
         messageConstEvalNotListOrSetInSpread,
         messageConstEvalNotMapInSpread,
+        messageConstEvalNonNull,
         messageConstEvalNullValue,
         messageConstEvalStartingPoint,
         messageConstEvalUnevaluated,
@@ -2238,6 +2239,18 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
             isNonNullableByDefault));
   }
 
+  @override
+  Constant visitNullCheck(NullCheck node) {
+    final Constant constant = _evaluateSubexpression(node.operand);
+    if (constant is NullConstant) {
+      return report(node, messageConstEvalNonNull);
+    }
+    if (shouldBeUnevaluated) {
+      return unevaluated(node, new NullCheck(extract(constant)));
+    }
+    return constant;
+  }
+
   @override
   Constant visitSymbolLiteral(SymbolLiteral node) {
     final Reference libraryReference =

pkg/front_end/messages.status

@@ -122,6 +122,8 @@ ConstEvalNegativeShift/example: Fail
 ConstEvalNonConstantVariableGet/example: Fail
 ConstEvalNotListOrSetInSpread/example: Fail
 ConstEvalNotMapInSpread/example: Fail
+ConstEvalNonNull/analyzerCode: Fail
+ConstEvalNonNull/example: Fail
 ConstEvalNullValue/example: Fail
 ConstEvalStartingPoint/analyzerCode: Fail # This is just used for displaying the starting point.
 ConstEvalStartingPoint/example: Fail # This is just used for displaying the starting point.

pkg/front_end/messages.yaml

@@ -132,6 +132,9 @@ ConstEvalNegativeShift:
 ConstEvalTruncateError:
   template: "Binary operator '#string ~/ #string2' results is Infinity or NaN."
 
+ConstEvalNonNull:
+  template: "Constant expression must be non-null."
+
 ConstEvalInvalidMethodInvocation:
   template: "The method '#string' can't be invoked on '#constant' in a constant expression."
   analyzerCode: UNDEFINED_OPERATOR

pkg/front_end/testcases/incremental_initialize_from_dill/flutter_widget_transform_nnbd.yaml

@@ -64,8 +64,7 @@ worlds:
             {
               "name": "flutter",
               "rootUri": "../flutter",
-              "packageUri": "lib/",
-              "languageVersion": "2.9"
+              "packageUri": "lib/"
             }
           ]
         }

pkg/front_end/testcases/incremental_initialize_from_dill/flutter_widget_transform_nnbd.yaml.world.2.expect

@@ -47,8 +47,14 @@ library from "org-dartlang-test:///main.dart" as main {
 
   import "org-dartlang-test:///foo.dart";
 
-  static field foo::Foo foo = invalid-expression "Constant evaluation has no support for NullCheck!";
+  static field foo::Foo foo = #C7;
 }
 constants  {
   #C1 = null
+  #C2 = "org-dartlang-test:///main.dart"
+  #C3 = 3.0
+  #C4 = 17.0
+  #C5 = <wid::_Location*>[]
+  #C6 = wid::_Location {file:#C2, line:#C3, column:#C4, name:#C1, parameterLocations:#C5}
+  #C7 = foo::Foo {_location:#C6}
 }

pkg/front_end/testcases/incremental_initialize_from_dill/flutter_widget_transformer_non_const.yaml

@@ -59,8 +59,7 @@ worlds:
             {
               "name": "flutter",
               "rootUri": "../flutter",
-              "packageUri": "lib/",
-              "languageVersion": "2.9"
+              "packageUri": "lib/"
             }
           ]
         }

pkg/front_end/testcases/nnbd/constant_null_check.dart

@@ -0,0 +1,27 @@
+// Copyright (c) 2020, 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.
+
+const int? a = 42;
+const int b = a!;
+
+const int? c = null;
+const int? d = c!;
+
+class Class {
+  final int y;
+  const Class(int? x) : y = x!;
+}
+
+const Class e = const Class(a);
+const Class f = const Class(c);
+
+main() {
+  expect(42, a);
+  expect(42, b);
+  expect(42, e.y);
+}
+
+expect(expected, actual) {
+  if (expected != actual) throw 'Expected $expected, actual $actual';
+}

pkg/front_end/testcases/nnbd/constant_null_check.dart.outline.expect

@@ -0,0 +1,20 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  final field core::int y;
+  const constructor •(core::int? x) → self::Class
+    : self::Class::y = x!, super core::Object::•()
+    ;
+}
+static const field core::int? a = 42;
+static const field core::int b = self::a!;
+static const field core::int? c = null;
+static const field core::int? d = self::c!;
+static const field self::Class e = const self::Class::•(self::a);
+static const field self::Class f = const self::Class::•(self::c);
+static method main() → dynamic
+  ;
+static method expect(dynamic expected, dynamic actual) → dynamic
+  ;

pkg/front_end/testcases/nnbd/constant_null_check.dart.strong.expect

@@ -0,0 +1,54 @@
+//
+// Problems in component:
+//
+// pkg/front_end/testcases/nnbd/constant_null_check.dart:9:17: Error: Constant evaluation error:
+// const int? d = c!;
+//                 ^
+// pkg/front_end/testcases/nnbd/constant_null_check.dart:9:17: Context: Constant expression must be non-null.
+// const int? d = c!;
+//                 ^
+// pkg/front_end/testcases/nnbd/constant_null_check.dart:9:12: Context: While analyzing:
+// const int? d = c!;
+//            ^
+//
+// pkg/front_end/testcases/nnbd/constant_null_check.dart:17:23: Error: Constant evaluation error:
+// const Class f = const Class(c);
+//                       ^
+// pkg/front_end/testcases/nnbd/constant_null_check.dart:13:30: Context: Constant expression must be non-null.
+//   const Class(int? x) : y = x!;
+//                              ^
+// pkg/front_end/testcases/nnbd/constant_null_check.dart:17:13: Context: While analyzing:
+// const Class f = const Class(c);
+//             ^
+//
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  final field core::int y;
+  const constructor •(core::int? x) → self::Class
+    : self::Class::y = x!, super core::Object::•()
+    ;
+}
+static const field core::int? a = #C1;
+static const field core::int b = #C1;
+static const field core::int? c = #C2;
+static const field core::int? d = invalid-expression "Constant expression must be non-null.";
+static const field self::Class e = #C3;
+static const field self::Class f = invalid-expression "Constant expression must be non-null.";
+static method main() → dynamic {
+  self::expect(42, #C1);
+  self::expect(42, #C1);
+  self::expect(42, (#C3).{self::Class::y});
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+constants  {
+  #C1 = 42
+  #C2 = null
+  #C3 = self::Class {y:#C1}
+}