Various checks for constant expressions.

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

 // Copyright (c) 2016, 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.
 
 library fasta.fasta_accessors;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelArguments;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
@@ skipping 21 matching lines @@
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
         ThisIndexAccessor,
         ThisPropertyAccessor,
         VariableAccessor;
 
 import 'kernel_builder.dart'
     show Builder, KernelClassBuilder, PrefixBuilder, TypeDeclarationBuilder;
 
-import '../names.dart' show callName;
+import '../names.dart' show callName, lengthName;
 
 abstract class BuilderHelper {
   Uri get uri;
 
   TypePromoter get typePromoter;
 
   int get functionNestingLevel;
 
   bool get constantExpressionRequired;
 
@@ skipping 30 matching lines @@
       String name, Arguments arguments, int offset,
       {bool isSuper, bool isGetter, bool isSetter});
 
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters);
 
   StaticGet makeStaticGet(Member readTarget, Token token);
 
   dynamic addCompileTimeError(int charOffset, String message, {bool silent});
 
+  bool isIdentical(Member member);
+
   Expression buildMethodInvocation(
       Expression receiver, Name name, Arguments arguments, int offset,
       {bool isConstantExpression, bool isNullAware});
 }
 
 abstract class FastaAccessor implements Accessor {
   BuilderHelper get helper;
 
   String get plainNameForRead;
 
@@ skipping 28 matching lines @@
   /* Expression | FastaAccessor | Initializer */ doInvocation(
       int offset, Arguments arguments);
 
   /* Expression | FastaAccessor */ buildPropertyAccess(
       IncompleteSend send, bool isNullAware) {
     if (send is SendAccessor) {
       return helper.buildMethodInvocation(buildSimpleRead(), send.name,
           send.arguments, offsetForToken(send.token),
           isNullAware: isNullAware);
     } else {
+      if (helper.constantExpressionRequired && send.name != lengthName) {
+        helper.addCompileTimeError(
+            offsetForToken(token), "Not a constant expression.");
+      }
       return PropertyAccessor.make(helper, send.token, buildSimpleRead(),
           send.name, null, null, isNullAware);
     }
   }
 
   /* Expression | FastaAccessor */ buildThrowNoSuchMethodError(
       Arguments arguments,
       {bool isSuper: false,
       bool isGetter: false,
       bool isSetter: false,
@@ skipping 534 matching lines @@
       if (builderSetter?.target?.hasSetter ?? false) {
         setter = builderSetter.target;
       }
     }
     return new StaticAccessor(helper, token, getter, setter);
   }
 
   String get plainNameForRead => (readTarget ?? writeTarget).name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
+    if (helper.constantExpressionRequired && !helper.isIdentical(readTarget)) {
+      helper.addCompileTimeError(offset, "Not a constant expression.");
+    }
     if (readTarget == null || isFieldOrGetter(readTarget)) {
       return helper.buildMethodInvocation(buildSimpleRead(), callName,
-          arguments, offset + (readTarget?.name?.name?.length ?? 0));
+          arguments, offset + (readTarget?.name?.name?.length ?? 0),
+          // This isn't a constant expression, but we have checked if a
+          // constant expression error should be emitted already.
+          isConstantExpression: true);
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "StaticAccessor()";
 }
 
 class SuperPropertyAccessor extends kernel.SuperPropertyAccessor
     with FastaAccessor {
   SuperPropertyAccessor(BuilderHelper helper, Token token, Name name,
       Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
+    if (helper.constantExpressionRequired) {
+      helper.addCompileTimeError(offset, "Not a constant expression.");
+    }
     if (getter == null || isFieldOrGetter(getter)) {
       return helper.buildMethodInvocation(
-          buildSimpleRead(), callName, arguments, offset);
+          buildSimpleRead(), callName, arguments, offset,
+          // This isn't a constant expression, but we have checked if a
+          // constant expression error should be emitted already.
+          isConstantExpression: true);
     } else {
       return new DirectMethodInvocation(new ThisExpression(), getter, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "SuperPropertyAccessor()";
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with FastaAccessor {
@@ skipping 136 matching lines @@
       {bool isGetter: false, bool isSetter: false, int offset}) {
     return helper.throwNoSuchMethodError(
         plainNameForRead, arguments, offset ?? offsetForToken(this.token),
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }