Add missing abort on duplicate class fields.

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 269 matching lines @@
 class ContainerElement extends Element {
   ContainerElement(name, kind, enclosingElement) :
     super(name, kind, enclosingElement);
 
   abstract void addMember(Element element, DiagnosticListener listener);
 
   void addGetterOrSetter(Element element,
                          Element existing,
                          DiagnosticListener listener) {
     void reportError(Element other) {
+      // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
       listener.cancel('duplicate definition of ${element.name.slowToString()}',
                       element: element);
       listener.cancel('existing definition', element: other);
     }
 
     if (existing != null) {
       if (existing.kind !== ElementKind.ABSTRACT_FIELD) {
         reportError(existing);
       } else {
         AbstractFieldElement field = existing;
@@ skipping 97 matching lines @@
     define(element, listener);
   }
 
   void define(Element element, DiagnosticListener listener) {
     if (element.kind == ElementKind.GETTER
         || element.kind == ElementKind.SETTER) {
       addGetterOrSetter(element, elements[element.name], listener);
     } else {
       Element existing = elements.putIfAbsent(element.name, () => element);
       if (existing !== element) {
+        // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
         listener.cancel('duplicate definition', token: element.position());
         listener.cancel('existing definition', token: existing.position());
       }
     }
   }
 
   /** Look up a top-level element in this library. The element could
     * potentially have been imported from another library. Returns
     * null if no such element exist. */
   Element find(SourceString elementName) {
@@ skipping 606 matching lines @@
 
   void addMember(Element element, DiagnosticListener listener) {
     members = members.prepend(element);
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
         element.modifiers.isFactory()) {
       constructors[element.name] = element;
     } else if (element.kind == ElementKind.GETTER
                || element.kind == ElementKind.SETTER) {
       addGetterOrSetter(element, localMembers[element.name], listener);
     } else {
-      localMembers[element.name] = element;
+      Element existing = localMembers.putIfAbsent(element.name, () => element);
+      if (existing !== element) {
+        // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
+        listener.cancel('duplicate definition', token: element.position());
+        listener.cancel('existing definition', token: existing.position());
+      }
     }
   }
 
   InterfaceType computeType(compiler) {
     if (type == null) {
       ClassNode node = parseNode(compiler);
       Link<Type> parameters =
           TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
       type = new InterfaceType(this, parameters);
     }
@@ skipping 368 matching lines @@
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, node, type, bound);
     return result;
   }
 }