It's not allowed to have an initializer for a final field that is initialized where it's declared.

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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 913 matching lines @@
   }
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
-  final Map<SourceString, Node> initialized;
+  final Map<Element, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
   InitializerResolver(this.visitor)
-    : initialized = new Map<SourceString, Node>(), hasSuper = false;
+    : initialized = new Map<Element, Node>(), hasSuper = false;
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
     visitor.error(node, kind, arguments);
   }
 
   warning(Node node, MessageKind kind, [arguments = const {}]) {
     visitor.warning(node, kind, arguments);
   }
 
   bool isFieldInitializer(SendSet node) {
     if (node.selector.asIdentifier() == null) return false;
     if (node.receiver == null) return true;
     if (node.receiver.asIdentifier() == null) return false;
     return node.receiver.asIdentifier().isThis();
   }
 
-  void checkForDuplicateInitializers(SourceString name, Node init) {
-    if (initialized.containsKey(name)) {
-      error(init, MessageKind.DUPLICATE_INITIALIZER, {'fieldName': name});
-      warning(initialized[name], MessageKind.ALREADY_INITIALIZED,
-              {'fieldName': name});
+  reportDuplicateInitializerError(Element field, Node init, Node existing) {
+    visitor.compiler.reportError(
+        init,
+        new ResolutionError(MessageKind.DUPLICATE_INITIALIZER,
+                            {'fieldName': field.name}));
+    visitor.compiler.reportMessage(
+        visitor.compiler.spanFromNode(existing),
+        new ResolutionError(MessageKind.ALREADY_INITIALIZED,
+                            {'fieldName': field.name}),
+        Diagnostic.INFO);
+  }
+
+  void checkForDuplicateInitializers(Element field, Node init) {
+    SourceString name = field.name;
+    if (initialized.containsKey(field)) {
+      reportDuplicateInitializerError(field, init, initialized[field]);
+    } else if (field.modifiers.isFinal()) {
+      Node fieldNode = field.parseNode(visitor.compiler).asSendSet();
+      if (fieldNode != null) {
+        reportDuplicateInitializerError(field, init, fieldNode);
+      }
     }
-    initialized[name] = init;
+    initialized[field] = init;
   }
 
   void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final SourceString name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
       target = constructor.getEnclosingClass().lookupLocalMember(name);
       if (target == null) {
         error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
       } else if (!target.isInstanceMember()) {
         error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     visitor.useElement(init, target);
     visitor.world.registerStaticUse(target);
-    checkForDuplicateInitializers(name, init);
+    checkForDuplicateInitializers(target, init);
     // Resolve initializing value.
     visitor.visitInStaticContext(init.arguments.head);
   }
 
   ClassElement getSuperOrThisLookupTarget(FunctionElement constructor,
                                           bool isSuperCall,
                                           Node diagnosticNode) {
     ClassElement lookupTarget = constructor.getEnclosingClass();
     if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
@@ skipping 118 matching lines @@
    * constructor, the resolved constructor's function element is returned.
    */
   FunctionElement resolveInitializers(FunctionElement constructor,
                                       FunctionExpression functionNode) {
     // Keep track of all "this.param" parameters specified for constructor so
     // that we can ensure that fields are initialized only once.
     FunctionSignature functionParameters =
         constructor.computeSignature(visitor.compiler);
     functionParameters.forEachParameter((Element element) {
       if (identical(element.kind, ElementKind.FIELD_PARAMETER)) {
-        checkForDuplicateInitializers(element.name,
+        FieldParameterElement fieldParameter = element;
+        checkForDuplicateInitializers(fieldParameter.fieldElement,
                                       element.parseNode(visitor.compiler));
       }
     });
 
     if (functionNode.initializers == null) {
       initializers = const Link<Node>();
     } else {
       initializers = functionNode.initializers.nodes;
     }
     FunctionElement result;
@@ skipping 2565 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }