Various errors on 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 '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 170 matching lines @@
           node.name.name, new Arguments.empty(), node.fileOffset,
           isGetter: true);
     } else if (node is BuilderAccessor) {
       return node.buildSimpleRead();
     } else if (node is TypeVariableBuilder) {
       TypeParameterType type = node.buildTypesWithBuiltArguments(library, null);
       if (!isInstanceContext && type.parameter.parent is Class) {
         return buildCompileTimeError(
             "Type variables can only be used in instance methods.");
       } else {
+        if (constantExpressionRequired) {
+          addCompileTimeError(-1,
+              "Type variable can't be used as a constant expression $type.");
+        }
         return new TypeLiteral(type);
       }
     } else if (node is TypeDeclarationBuilder) {
       return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
     } else if (node is KernelTypeBuilder) {
       return new TypeLiteral(node.build(library));
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
       return buildCompileTimeError("A library can't be used as an expression.");
@@ skipping 332 matching lines @@
     } else if (arguments == null) {
       push(receiver);
     } else {
       push(finishSend(receiver, arguments, beginToken.charOffset));
     }
   }
 
   @override
   finishSend(Object receiver, Arguments arguments, int charOffset) {
     if (receiver is BuilderAccessor) {
+      if (constantExpressionRequired) {
+        addCompileTimeError(charOffset, "Not a constant expression.");
+      }
       return receiver.doInvocation(charOffset, arguments);
     } else if (receiver is UnresolvedIdentifier) {
       return throwNoSuchMethodError(
           receiver.name.name, arguments, receiver.fileOffset);
     } else {
       return buildMethodInvocation(
           toValue(receiver), callName, arguments, charOffset);
     }
   }
 
@@ skipping 187 matching lines @@
     String name = token.lexeme;
     if (context.isScopeReference) {
       assert(!inInitializer ||
           this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
       Builder builder = scope.lookup(name, token.charOffset, uri);
       push(builderToFirstExpression(builder, name, token.charOffset));
     } else {
+      if (constantExpressionRequired) {
+        if (context != IdentifierContext.namedArgumentReference &&
+            context != IdentifierContext.constructorReferenceContinuation &&
+            context != IdentifierContext.expressionContinuation &&
+            context != IdentifierContext.typeReferenceContinuation &&
+            context != IdentifierContext.localVariableDeclaration &&
+            context !=
+                IdentifierContext
+                    .constructorReferenceContinuationAfterTypeArguments) {
+          addCompileTimeError(
+              token.charOffset, "Not a constant expression: $context");
+        }
+      }
       push(new Identifier(name)..fileOffset = token.charOffset);
     }
   }
 
   @override
   builderToFirstExpression(Builder builder, String name, int charOffset,
       {bool isPrefix: false}) {
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
       if (!isPrefix && isInstanceContext) {
         assert(builder == null);
+        if (constantExpressionRequired) {
+          addCompileTimeError(charOffset, "Not a constant expression.");
+        }
         return new ThisPropertyAccessor(this, charOffset, n, null, null);
       } else {
+        if (constantExpressionRequired) {
+          addCompileTimeError(charOffset, "Not a constant expression.");
+        }
         return new UnresolvedIdentifier(n)..fileOffset = charOffset;
       }
     } else if (builder.isTypeDeclaration) {
+      if (constantExpressionRequired && builder.isTypeVariable) {
+        addCompileTimeError(charOffset, "Not a constant expression.");
+      }
       return builder;
     } else if (builder.isLocal) {
+      if (constantExpressionRequired && !builder.isConst) {
+        addCompileTimeError(charOffset, "Not a constant expression.");
+      }
       return new VariableAccessor(this, charOffset, builder.target);
     } else if (builder.isInstanceMember) {
+      if (constantExpressionRequired) {
+        addCompileTimeError(charOffset, "Not a constant expression.");
+      }
       return new ThisPropertyAccessor(
           this, charOffset, new Name(name, library.library), null, null);
     } else if (builder.isRegularMethod) {
       assert(builder.isStatic || builder.isTopLevel);
       return new StaticAccessor(this, charOffset, builder.target, null);
     } else if (builder is PrefixBuilder) {
       return builder;
     } else if (builder is MixedAccessor) {
+      if (constantExpressionRequired && !builder.getter.target.isConst) {
+        addCompileTimeError(charOffset, "Not a constant expression.");
+      }
       return new StaticAccessor(
           this, charOffset, builder.getter.target, builder.setter.target);
     } else {
       if (builder.hasProblem && builder is! AccessErrorBuilder) return builder;
       Builder setter;
       if (builder.isSetter) {
         setter = builder;
       } else if (builder.isGetter) {
         setter = scope.lookupSetter(name, charOffset, uri);
       } else if (builder.isField && !builder.isFinal) {
         setter = builder;
       }
-      return new StaticAccessor.fromBuilder(this, builder, charOffset, setter);
+      StaticAccessor accessor =
+          new StaticAccessor.fromBuilder(this, builder, charOffset, setter);
+      if (constantExpressionRequired) {
+        Member readTarget = accessor.readTarget;
+        if (!(readTarget is Field && readTarget.isConst)) {
+          addCompileTimeError(charOffset, "Not a constant expression.");
+        }
+      }
+      return accessor;
     }
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");
     Identifier name = pop();
     var receiver = pop();
     push([receiver, name]);
   }
@@ skipping 407 matching lines @@
     if (builder == null) {
       warning("Type not found: '$name'.", charOffset);
       return const DynamicType();
     } else {
       return kernelTypeFromBuilder(builder, arguments, charOffset);
     }
   }
 
   DartType kernelTypeFromBuilder(
       Builder builder, List<DartType> arguments, int charOffset) {
+    if (constantExpressionRequired && builder is TypeVariableBuilder) {
+      addCompileTimeError(charOffset, "Not a constant expression.");
+    }
     if (builder is TypeDeclarationBuilder) {
       return builder.buildTypesWithBuiltArguments(library, arguments);
     } else if (builder.hasProblem) {
       ProblemBuilder problem = builder;
       addCompileTimeError(charOffset, problem.message);
     } else {
       warning("Not a type: '${builder.fullNameForErrors}'.", charOffset);
     }
     // TODO(ahe): Create an error somehow.
     return const DynamicType();
@@ skipping 37 matching lines @@
     if (name is Identifier) {
       name = name.name;
     }
     if (name is BuilderAccessor) {
       warning("'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is UnresolvedIdentifier) {
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
+      if (constantExpressionRequired) {
+        addCompileTimeError(
+            beginToken.charOffset, "Not a constant expression.");
+      }
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeDeclarationBuilder) {
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeBuilder) {
       push(name.build(library));
     } else if (name is Builder) {
       push(kernelTypeFromBuilder(name, arguments, beginToken.charOffset));
     } else if (name is String) {
       push(kernelTypeFromString(name, arguments, beginToken.charOffset));
     } else {
@@ skipping 1056 matching lines @@
     push(new Operator(token.stringValue)..fileOffset = token.charOffset);
   }
 
   @override
   void handleSymbolVoid(Token token) {
     logEvent("SymbolVoid");
   }
 
   dynamic addCompileTimeError(int charOffset, String message,
       {bool silent: false}) {
+    // TODO(ahe): If constantExpressionRequired is set, set it to false to
+    // avoid a long list of errors.
     return library.addCompileTimeError(charOffset, message, fileUri: uri);
   }
 
   @override
   void handleInvalidFunctionBody(Token token) {
     if (member.isNative) {
       push(NullValue.FunctionBody);
     } else {
       push(new Block(<Statement>[new InvalidStatement()]));
     }
   }
 
   @override
+  void warning(String message, [int charOffset = -1]) {
+    if (constantExpressionRequired) {
+      addCompileTimeError(charOffset, message);
+    } else {
+      super.warning(message, charOffset);
+    }
+  }
+
+  @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }
 
 // TODO(ahe): Shouldn't need to be an expression.
 class UnresolvedIdentifier extends InvalidExpression {
   final Name name;
 
   UnresolvedIdentifier(this.name);
@@ skipping 438 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }