Various checks for constant expressions.

pkg/front_end/lib/src/fasta/kernel/body_builder.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.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
@@ skipping 632 matching lines @@
       }
     } else if (arguments == null) {
       push(receiver);
     } else {
       push(finishSend(receiver, arguments, beginToken.charOffset));
     }
   }
 
   @override
   finishSend(Object receiver, Arguments arguments, int charOffset) {
-    bool isIdentical(Object receiver) {
-      return receiver is StaticAccessor &&
-          receiver.readTarget == coreTypes.identicalProcedure;
-    }
-
     if (receiver is FastaAccessor) {
-      if (constantExpressionRequired &&
-          !isIdentical(receiver) &&
-          !receiver.isInitializer) {
-        addCompileTimeError(charOffset, "Not a constant expression.");
-      }
       return receiver.doInvocation(charOffset, arguments);
     } else {
       return buildMethodInvocation(
           toValue(receiver), callName, arguments, charOffset);
     }
   }
 
   @override
   void beginCascade(Token token) {
     debugEvent("beginCascade");
@@ skipping 13 matching lines @@
   @override
   void endCascade() {
     debugEvent("endCascade");
     Expression expression = popForEffect();
     KernelCascadeExpression cascadeReceiver = pop();
     cascadeReceiver.finalize(expression);
     push(cascadeReceiver);
   }
 
   @override
+  void beginCaseExpression(Token caseKeyword) {
+    debugEvent("beginCaseExpression");
+    super.push(constantExpressionRequired);
+    constantExpressionRequired = true;
+  }
+
+  @override
+  void endCaseExpression(Token colon) {
+    debugEvent("endCaseExpression");
+    Expression expression = popForValue();
+    constantExpressionRequired = pop();
+    super.push(expression);
+  }
+
+  @override
   void handleBinaryExpression(Token token) {
     debugEvent("BinaryExpression");
     if (optional(".", token) || optional("..", token)) {
       return doDotOrCascadeExpression(token);
     }
     if (optional("&&", token) || optional("||", token)) {
       return doLogicalExpression(token);
     }
     if (optional("??", token)) return doIfNull(token);
     if (optional("?.", token)) return doIfNotNull(token);
@@ skipping 995 matching lines @@
     Identifier name = pop();
     push(new InitializedIdentifier(name.token, initializer));
   }
 
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
   }
 
   @override
+  void beginFormalParameters(Token token, MemberKind kind) {
+    super.push(constantExpressionRequired);
+    constantExpressionRequired = false;
+  }
+
+  @override
   void endFormalParameters(
       int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     OptionalFormals optional;
     if (count > 0 && peek() is OptionalFormals) {
       optional = pop();
       count--;
     }
     FormalParameters formals = new FormalParameters(
         popList(count) ?? <VariableDeclaration>[],
         optional,
         beginToken.charOffset);
+    constantExpressionRequired = pop();
     push(formals);
     if ((inCatchClause || functionNestingLevel != 0) &&
         kind != MemberKind.GeneralizedFunctionType) {
       enterLocalScope(formals.computeFormalParameterScope(
           scope, member ?? classBuilder ?? library, this));
     }
   }
 
   @override
   void beginCatchClause(Token token) {
@@ skipping 93 matching lines @@
       }
       if (receiver is ThisAccessor && receiver.isSuper) {
         push(toSuperMethodInvocation(buildMethodInvocation(
             new KernelThisExpression()
               ..fileOffset = offsetForToken(receiver.token),
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
         push(buildMethodInvocation(toValue(receiver), new Name(operator),
-            new Arguments.empty(), token.charOffset));
+            new Arguments.empty(), token.charOffset,
+            // This *could* be a constant expression, we can't know without
+            // evaluating [receiver].
+            isConstantExpression: true));
       }
     }
   }
 
   Name incrementOperator(Token token) {
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
     return internalError("Unknown increment operator: ${token.lexeme}");
   }
 
@@ skipping 921 matching lines @@
     }
     for (Expression argument in expressions.reversed) {
       expression = new Let(
           new VariableDeclaration.forValue(argument, isFinal: true),
           expression);
     }
     return expression;
   }
 
   @override
+  bool isIdentical(Member member) => member == coreTypes.identicalProcedure;
+
+  @override
   Expression buildMethodInvocation(
       Expression receiver, Name name, Arguments arguments, int offset,
       {bool isConstantExpression: false, bool isNullAware: false}) {
+    if (constantExpressionRequired && !isConstantExpression) {
+      return buildCompileTimeError("Not a constant expression.", offset);
+    }
     if (isNullAware) {
       VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
       return makeLet(
           variable,
           new ConditionalExpression(
               buildIsNull(new VariableGet(variable)),
               new NullLiteral(),
               new MethodInvocation(new VariableGet(variable), name, arguments)
                 ..fileOffset = offset,
               const DynamicType()));
@@ skipping 477 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }