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 138 matching lines @@
     if (send is SendAccessor) {
       // Notice that 'this' or 'super' can't be null. So we can ignore the
       // value of [isNullAware].
       MethodInvocation result = helper.buildMethodInvocation(
           new ThisExpression(),
           send.name,
           send.arguments,
           offsetForToken(token));
       return isSuper ? helper.toSuperMethodInvocation(result) : result;
     } else {
+      if (!isInitializer && helper.constantExpressionRequired) {
+        // TODO(ahe): Remove this?

[ahe, 2017/05/30 09:56:28]

I've invested the 50-60 minutes it took to answer this question, and I can
remove it :-)

+        helper.addCompileTimeError(
+            offsetForToken(token), "Not a constant expression.");
+      }
       if (isSuper) {
         Member getter = helper.lookupSuperMember(send.name);
         Member setter = helper.lookupSuperMember(send.name, isSetter: true);
         return new SuperPropertyAccessor(
             helper, send.token, send.name, getter, setter);
       } else {
         return new ThisPropertyAccessor(
             helper, send.token, send.name, null, null);
       }
     }
@@ skipping 376 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);
 }