Check const constructors.

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, optional;
@@ skipping 559 matching lines @@
 
   @override
   finishSend(Object receiver, Arguments arguments, int charOffset) {
     bool isIdentical(Object receiver) {
       return receiver is StaticAccessor &&
           receiver.readTarget ==
               coreTypes.tryGetTopLevelMember("dart:core", null, "identical");
     }
 
     if (receiver is FastaAccessor) {
-      if (constantExpressionRequired && !isIdentical(receiver)) {
+      if (constantExpressionRequired &&
+          !isIdentical(receiver) &&
+          !receiver.isInitializer) {

[Paul Berry, 2017/04/07 15:59:19]

It looks like isInitializer isn't defined on FastaAccessor.  Am I missing
something?

[ahe, 2017/04/07 18:11:15]

That part got included in CL 2800083002 by accident.

         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return receiver.doInvocation(charOffset, arguments);
     } else {
       return buildMethodInvocation(
           toValue(receiver), callName, arguments, charOffset);
     }
   }
 
   @override
@@ skipping 126 matching lines @@
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
     return true;
   }
 
   @override
   Expression throwNoSuchMethodError(
       String name, Arguments arguments, int charOffset,
       {bool isSuper: false, isGetter: false, isSetter: false}) {
     String errorName = isSuper ? "super.$name" : name;
+    String message;
     if (isGetter) {
-      warning("Getter not found: '$errorName'.", charOffset);
+      message = "Getter not found: '$errorName'.";
     } else if (isSetter) {
-      warning("Setter not found: '$errorName'.", charOffset);
+      message = "Setter not found: '$errorName'.";
     } else {
-      warning("Method not found: '$errorName'.", charOffset);
+      message = "Method not found: '$errorName'.";
     }
+    if (constantExpressionRequired) {
+      return buildCompileTimeError(message, charOffset);
+    }
+    warning(message, charOffset);
     Constructor constructor =
         coreTypes.getClass("dart:core", "NoSuchMethodError").constructors.first;
     return new Throw(new ConstructorInvocation(
         constructor,
         new Arguments(<Expression>[
           new NullLiteral(),
           new SymbolLiteral(name),
           new ListLiteral(arguments.positional),
           new MapLiteral(arguments.named.map((arg) {
             return new MapEntry(new SymbolLiteral(arg.name), arg.value);
@@ skipping 77 matching lines @@
       } else if (isDartLibrary &&
           name == "main" &&
           library.uri.path == "_builtin" &&
           member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
         return new NullLiteral()..fileOffset = charOffset;
       } else {
         return new UnresolvedAccessor(this, n, charOffset);
       }
     } else if (builder.isTypeDeclaration) {
-      if (constantExpressionRequired && builder.isTypeVariable) {
+      if (constantExpressionRequired &&
+          builder.isTypeVariable &&
+          !member.isConstructor) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return builder;
     } else if (builder.isLocal) {
-      if (constantExpressionRequired && !builder.isConst) {
+      if (constantExpressionRequired &&
+          !builder.isConst &&
+          !member.isConstructor) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return new VariableAccessor(this, charOffset, builder.target);
     } else if (builder.isInstanceMember) {
-      if (constantExpressionRequired) {
+      if (constantExpressionRequired &&
+          !inInitializer &&
+          // TODO(ahe): This is a hack because Fasta sets up the scope
+          // "this.field" parameters according to old semantics. Under the new
+          // semantics, such parameters introduces a new parameter with that
+          // name that should be resolved here.
+          !member.isConstructor) {
         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) {
       if (constantExpressionRequired && builder.deferred) {
         addCompileTimeError(
@@ skipping 512 matching lines @@
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is FastaAccessor) {
       warningNotError(
           "'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
-    } else if (name is TypeVariableBuilder) {
+    } else if (name is TypeVariableBuilder && !member.isConstructor) {
       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) {
@@ skipping 1655 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }