Emit a compile-time error on const constructors with a body.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 343 matching lines @@
       if (element.isPatched) {
         checkMatchingPatchSignatures(element, element.patch);
         element = element.patch;
       }
       return compiler.withCurrentElement(element, () {
         FunctionExpression tree = element.parseNode(compiler);
         if (tree.modifiers.isExternal()) {
           error(tree, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
           return;
         }
-        if (isConstructor) {
+        if (isConstructor || element.isFactoryConstructor()) {
           if (tree.returnType != null) {
             error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
           }
+          if (element.modifiers.isConst() &&
+              tree.hasBody() &&
+              !tree.isRedirectingFactory) {
+            compiler.reportError(tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
+          }
         }
+
         ResolverVisitor visitor = visitorFor(element);
         visitor.useElement(tree, element);
         visitor.setupFunction(tree, element);
 
         if (isConstructor && !element.isForwardingConstructor) {
           // Even if there is no initializer list we still have to do the
           // resolution in case there is an implicit super constructor call.
           InitializerResolver resolver = new InitializerResolver(visitor);
           FunctionElement redirection =
               resolver.resolveInitializers(element, tree);
@@ skipping 852 matching lines @@
         resolveFieldInitializer(constructor, init);
       } else if (link.head.asSend() != null) {
         final Send call = link.head.asSend();
         if (Initializers.isSuperConstructorCall(call)) {
           if (resolvedSuper) {
             error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
           }
           resolveSuperOrThisForSend(constructor, functionNode, call);
           resolvedSuper = true;
         } else if (Initializers.isConstructorRedirect(call)) {
-          // Check that there is no body (Language specification 7.5.1).
-          if (functionNode.hasBody()) {
+          // Check that there is no body (Language specification 7.5.1).  If the
+          // constructor is also const, we already reported an error in
+          // [resolveMethodElement].
+          if (functionNode.hasBody() && !constructor.modifiers.isConst()) {
             error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
           }
           // Check that there are no other initializers.
           if (!initializers.tail.isEmpty) {
             error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
           }
           // Check that there are no field initializing parameters.
           Compiler compiler = visitor.compiler;
           FunctionSignature signature = constructor.computeSignature(compiler);
           signature.forEachParameter((Element parameter) {
@@ skipping 2861 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }