[CFE] Fail at runtime when a const constructor redirects to a non-const

If a const constructor redirects to a non-const constructor, report a
compile-time error (no change here).

At runtime, a const instantiation will result in an invalid expression,
whereas a non-const (explicit or implicit new) instantiation will
work normally.

Closes #23622

Change-Id: Ief0e9c62fb8de34203df49fd862f20aba41a3cde
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/120042
Commit-Queue: Aske Simon Christensen <askesc@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>

Author: askeksa

pkg/front_end/lib/src/fasta/fasta_codes_generated.dart

@@ -1054,7 +1054,7 @@ const MessageCode messageConstConstructorWithNonConstSuper = const MessageCode(
     "ConstConstructorWithNonConstSuper",
     analyzerCodes: <String>["CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER"],
     message:
-        r"""Constant constructor can't call non-constant super constructors.""");
+        r"""A constant constructor can't call a non-constant super constructor.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeConstEvalCircularity = messageConstEvalCircularity;

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

@@ -5029,15 +5029,6 @@ class BodyBuilder extends ScopeListener<JumpTarget>
       ..fileOffset = charOffset;
   }
 
-  Initializer buildInvalidSuperInitializer(
-      Constructor target, ArgumentsImpl arguments, Expression expression,
-      [int charOffset = -1]) {
-    needsImplicitSuperInitializer = false;
-    return new InvalidSuperInitializerJudgment(
-        target, arguments, new VariableDeclaration.forValue(expression))
-      ..fileOffset = charOffset;
-  }
-
   Initializer buildDuplicatedInitializer(Field field, Expression value,
       String name, int offset, int previousInitializerOffset) {
     return new ShadowInvalidFieldInitializer(
@@ -5139,12 +5130,8 @@ class BodyBuilder extends ScopeListener<JumpTarget>
       bool isSynthetic, Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     if (member.isConst && !constructor.isConst) {
-      return buildInvalidSuperInitializer(
-          constructor,
-          arguments,
-          buildProblem(fasta.messageConstConstructorWithNonConstSuper,
-              charOffset, constructor.name.name.length),
-          charOffset);
+      addProblem(fasta.messageConstConstructorWithNonConstSuper, charOffset,
+          constructor.name.name.length);
     }
     needsImplicitSuperInitializer = false;
     return new SuperInitializer(constructor, arguments)

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

@@ -893,18 +893,9 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
   @override
   Constant visitConstructorInvocation(ConstructorInvocation node) {
     final Constructor constructor = node.target;
+    checkConstructorConst(node, constructor);
+
     final Class klass = constructor.enclosingClass;
-    bool isSymbol = klass == coreTypes.internalSymbolClass;
-    if (!constructor.isConst) {
-      return reportInvalid(node, 'Non-const constructor invocation.');
-    }
-    if (constructor.function.body != null &&
-        constructor.function.body is! EmptyStatement) {
-      return reportInvalid(
-          node,
-          'Constructor "$node" has non-trivial body '
-          '"${constructor.function.body.runtimeType}".');
-    }
     if (klass.isAbstract) {
       return reportInvalid(
           node, 'Constructor "$node" belongs to abstract class "${klass}".');
@@ -914,6 +905,7 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
         evaluatePositionalArguments(node.arguments);
     final Map<String, Constant> named = evaluateNamedArguments(node.arguments);
 
+    bool isSymbol = klass == coreTypes.internalSymbolClass;
     if (isSymbol && shouldBeUnevaluated) {
       return unevaluated(
           node,
@@ -964,6 +956,19 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
     });
   }
 
+  void checkConstructorConst(TreeNode node, Constructor constructor) {
+    if (!constructor.isConst) {
+      reportInvalid(node, 'Non-const constructor invocation.');
+    }
+    if (constructor.function.body != null &&
+        constructor.function.body is! EmptyStatement) {
+      reportInvalid(
+          node,
+          'Constructor "$node" has non-trivial body '
+          '"${constructor.function.body.runtimeType}".');
+    }
+  }
+
   @override
   Constant visitInstanceCreation(InstanceCreation node) {
     return withNewInstanceBuilder(node.classNode, node.typeArguments, () {
@@ -1159,6 +1164,7 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
             env.addVariableValue(
                 variable, _evaluateSubexpression(variable.initializer));
           } else if (init is SuperInitializer) {
+            checkConstructorConst(init, constructor);
             handleConstructorInvocation(
                 init.target,
                 evaluateSuperTypeArguments(
@@ -1168,6 +1174,7 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
           } else if (init is RedirectingInitializer) {
             // Since a redirecting constructor targets a constructor of the same
             // class, we pass the same [typeArguments].
+            checkConstructorConst(init, constructor);
             handleConstructorInvocation(
                 init.target,
                 typeArguments,

pkg/front_end/messages.status

@@ -69,7 +69,6 @@ ConstAndFinal/part_wrapped_declaration4: Fail
 ConstConstructorInSubclassOfMixinApplication/example: Fail
 ConstConstructorNonFinalField/example: Fail
 ConstConstructorRedirectionToNonConst/analyzerCode: Fail # The analyzer doesn't report this error.
-ConstConstructorWithNonConstSuper/example: Fail
 ConstEvalCircularity/example: Fail
 ConstEvalContext/analyzerCode: Fail # This is just used for displaying the context.
 ConstEvalContext/example: Fail # This is just used for displaying the context.

pkg/front_end/messages.yaml

@@ -738,10 +738,6 @@ SuperInitializerNotLast:
   script:
     - "class C { int x; C.bad() : super(), x = 5; }"
 
-ConstConstructorWithNonConstSuper:
-  template: "Constant constructor can't call non-constant super constructors."
-  analyzerCode: CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER
-
 ExtraneousModifier:
   index: 77
   template: "Can't have modifier '#lexeme' here."
@@ -2703,6 +2699,18 @@ ConstConstructorRedirectionToNonConst:
         A.bar() {}
       }
 
+ConstConstructorWithNonConstSuper:
+  template: "A constant constructor can't call a non-constant super constructor."
+  analyzerCode: CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER
+  script:
+    - >-
+      class A {
+        A.bar() {}
+      }
+      class B extends A {
+        const B.foo() : super.bar();
+      }
+
 AccessError:
   template: "Access error: '#name'."
 

pkg/front_end/testcases/general/const_redirect_to_nonconst.dart

@@ -0,0 +1,23 @@
+// Copyright (c) 2019, 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.
+
+class A {
+  const A() : this.bad();
+
+  A.bad() {}
+}
+
+class B extends A {
+  const B() : super.bad();
+}
+
+test() {
+  print(const A());
+  print(const B());
+}
+
+main() {
+  print(new A());
+  print(new B());
+}

pkg/front_end/testcases/general/const_redirect_to_nonconst.dart.outline.expect

@@ -0,0 +1,27 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/const_redirect_to_nonconst.dart:12:21: Error: A constant constructor can't call a non-constant super constructor.
+//   const B() : super.bad();
+//                     ^^^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  const constructor •() → self::A*
+    : this self::A::bad()
+    ;
+  constructor bad() → self::A*
+    ;
+}
+class B extends self::A {
+  const constructor •() → self::B*
+    : super self::A::bad()
+    ;
+}
+static method test() → dynamic
+  ;
+static method main() → dynamic
+  ;

pkg/front_end/testcases/general/const_redirect_to_nonconst.dart.strong.expect

@@ -0,0 +1,35 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/const_redirect_to_nonconst.dart:12:21: Error: A constant constructor can't call a non-constant super constructor.
+//   const B() : super.bad();
+//                     ^^^
+//
+// pkg/front_end/testcases/general/const_redirect_to_nonconst.dart:6:20: Error: A constant constructor can't call a non-constant constructor.
+//   const A() : this.bad();
+//                    ^^^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  const constructor •() → self::A*
+    : this self::A::bad()
+    ;
+  constructor bad() → self::A*
+    : super core::Object::•() {}
+}
+class B extends self::A {
+  const constructor •() → self::B*
+    : super self::A::bad()
+    ;
+}
+static method test() → dynamic {
+  core::print(invalid-expression "Non-const constructor invocation.");
+  core::print(invalid-expression "Non-const constructor invocation.");
+}
+static method main() → dynamic {
+  core::print(new self::A::•());
+  core::print(new self::B::•());
+}

pkg/front_end/testcases/general/const_redirect_to_nonconst.dart.strong.transformed.expect

@@ -0,0 +1,35 @@
+library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/const_redirect_to_nonconst.dart:12:21: Error: A constant constructor can't call a non-constant super constructor.
+//   const B() : super.bad();
+//                     ^^^
+//
+// pkg/front_end/testcases/general/const_redirect_to_nonconst.dart:6:20: Error: A constant constructor can't call a non-constant constructor.
+//   const A() : this.bad();
+//                    ^^^
+//
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  const constructor •() → self::A*
+    : this self::A::bad()
+    ;
+  constructor bad() → self::A*
+    : super core::Object::•() {}
+}
+class B extends self::A {
+  const constructor •() → self::B*
+    : super self::A::bad()
+    ;
+}
+static method test() → dynamic {
+  core::print(invalid-expression "Non-const constructor invocation.");
+  core::print(invalid-expression "Non-const constructor invocation.");
+}
+static method main() → dynamic {
+  core::print(new self::A::•());
+  core::print(new self::B::•());
+}

pkg/front_end/testcases/text_serialization.status

@@ -120,6 +120,7 @@ general/closure: TextSerializationFailure # Was: Pass
 general/co19_language_metadata_syntax_t04: TextSerializationFailure # Was: Pass
 general/complex_class_hierarchy: TextSerializationFailure
 general/compound_binary_implicit_as: TextSerializationFailure
+general/const_redirect_to_nonconst: TextSerializationFailure
 general/constructor_const_inference: TextSerializationFailure # Was: Pass
 general/constructor_cycle: TextSerializationFailure # Was: Pass
 general/constructor_function_types: TextSerializationFailure # Was: Pass