Non fatal errors on duplicated accessors

dart/pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
 import '../resolution/class_members.dart' show ClassMemberMixin;
 
 import '../dart2jslib.dart' show
     Backend,
     Compiler,
-    CompilerCancelledException,
     Constant,
     DartType,
     DiagnosticListener,
     DualKind,
     FunctionType,
     InterfaceType,
     MessageKind,
     Script,
     Selector,
     TypeVariableType,
@@ skipping 364 matching lines @@
     }
     if (unwrapped.isWarnOnUse) {
       unwrapped = unwrapped.unwrap(listener, usageSpannable);
     }
     return unwrapped;
   }
 
   accept(ElementVisitor visitor) => visitor.visitWarnOnUseElement(this);
 }
 
-class AmbiguousElementX extends ElementX implements AmbiguousElement {
+abstract class AmbiguousElementX extends ElementX implements AmbiguousElement {
   /**
    * The message to report on resolving this element.
    */
   final MessageKind messageKind;
 
   /**
    * The message arguments to report on resolving this element.
    */
   final Map messageArguments;
 
@@ skipping 18 matching lines @@
     var set = new Setlet();
     while (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       set.add(ambiguous.newElement);
       element = ambiguous.existingElement;
     }
     set.add(element);
     return set;
   }
 
+  accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(this);
+
+  bool get isTopLevel => false;
+}
+
+/// Element synthesized to diagnose an ambiguous import.
+class AmbiguousImportX extends AmbiguousElementX {
+  AmbiguousImportX(
+      MessageKind messageKind,
+      Map messageArguments,
+      Element enclosingElement, Element existingElement, Element newElement)
+      : super(messageKind, messageArguments, enclosingElement, existingElement,
+              newElement);
+
   void diagnose(Element context, DiagnosticListener listener) {
     Setlet ambiguousElements = flatten();
     MessageKind code = (ambiguousElements.length == 1)
         ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
     LibraryElementX importer = context.library;
     for (Element element in ambiguousElements) {
       var arguments = {'name': element.name};
       listener.reportInfo(element, code, arguments);
       Link<Import> importers = importer.importers.getImports(element);
       listener.withCurrentElement(importer, () {
         for (; !importers.isEmpty; importers = importers.tail) {
           listener.reportInfo(
               importers.head, MessageKind.IMPORTED_HERE, arguments);
         }
       });
     }
   }
+}
 
-  accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(this);
-
-  bool get isTopLevel => false;
+/// Element synthesized to recover from a duplicated member of an element.
+class DuplicatedElementX extends AmbiguousElementX {
+  DuplicatedElementX(
+      MessageKind messageKind,
+      Map messageArguments,
+      Element enclosingElement, Element existingElement, Element newElement)
+      : super(messageKind, messageArguments, enclosingElement, existingElement,
+              newElement);
 }
 
 class ScopeX {
   final Map<String, Element> contents = new Map<String, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(String name) {
     return contents[name];
@@ skipping 29 matching lines @@
    */
   void addAccessor(FunctionElementX accessor,
                    Element existing,
                    DiagnosticListener listener) {
     void reportError(Element other) {
       listener.reportError(accessor,
                            MessageKind.DUPLICATE_DEFINITION,
                            {'name': accessor.name});
       listener.reportInfo(
           other, MessageKind.EXISTING_DEFINITION, {'name': accessor.name});
-      // TODO(ahe): Don't throw, recover from error.
-      throw new CompilerCancelledException(null);
+
+      contents[accessor.name] = new DuplicatedElementX(
+          MessageKind.DUPLICATE_DEFINITION, {'name': accessor.name},
+          accessor.memberContext.enclosingElement, other, accessor);
     }
 
     if (existing != null) {
       if (!identical(existing.kind, ElementKind.ABSTRACT_FIELD)) {
         reportError(existing);
         return;
       } else {
         AbstractFieldElementX field = existing;
         accessor.abstractField = field;
         if (accessor.isGetter) {
@@ skipping 187 matching lines @@
         if (import == null) {
           // [element] is imported implicitly (probably through dart:core).
           registerWarnOnUseElement(
               existingImport, MessageKind.HIDDEN_IMPLICIT_IMPORT,
               existing, element);
         } else {
           registerWarnOnUseElement(
               import, MessageKind.HIDDEN_IMPORT, existing, element);
         }
       } else {
-        Element ambiguousElement = new AmbiguousElementX(
+        Element ambiguousElement = new AmbiguousImportX(
             MessageKind.DUPLICATE_IMPORT, {'name': name},
             enclosingElement, existing, element);
         importScope[name] = ambiguousElement;
         importers.registerImport(ambiguousElement, import);
         importers.registerImport(ambiguousElement, existingImport);
       }
     }
   }
 
   Element operator [](String name) => importScope[name];
@@ skipping 2185 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }