Version 0.8.10.8

dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/verifier/ErrorVerifier.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 317 matching lines @@
    * A table mapping name of the library to the export directive which export this library.
    */
   private HashMap<String, LibraryElement> nameToExportElement = new HashMap<String, LibraryElement>();
 
   /**
    * A table mapping name of the library to the import directive which import this library.
    */
   private HashMap<String, LibraryElement> nameToImportElement = new HashMap<String, LibraryElement>();
 
   /**
-   * A table mapping names to the export elements exported them.
+   * A table mapping names to the exported elements.
    */
-  private HashMap<String, ExportElement> exportedNames = new HashMap<String, ExportElement>();
+  private HashMap<String, Element> exportedElements = new HashMap<String, Element>();
 
   /**
    * A set of the names of the variable initializers we are visiting now.
    */
   private HashSet<String> namesForReferenceToDeclaredVariableInInitializer = new HashSet<String>();
 
   /**
    * A list of types used by the {@link CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS} and
    * {@link CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS} error codes.
    */
@@ skipping 1372 matching lines @@
       return false;
     }
     ExportElement exportElement = (ExportElement) node.getElement();
     // prepare exported library
     LibraryElement exportedLibrary = exportElement.getExportedLibrary();
     if (exportedLibrary == null) {
       return false;
     }
     // check exported names
     Namespace namespace = new NamespaceBuilder().createExportNamespace(exportElement);
-    Set<String> newNames = namespace.getDefinedNames().keySet();
-    for (String name : newNames) {
-      ExportElement prevElement = exportedNames.get(name);
-      if (prevElement != null && prevElement != exportElement) {
+    Map<String, Element> definedNames = namespace.getDefinedNames();
+    for (Entry<String, Element> definedEntry : definedNames.entrySet()) {
+      String name = definedEntry.getKey();
+      Element element = definedEntry.getValue();
+      Element prevElement = exportedElements.get(name);
+      if (element != null && prevElement != null && !prevElement.equals(element)) {
         errorReporter.reportError(
             CompileTimeErrorCode.AMBIGUOUS_EXPORT,
             node,
             name,
-            prevElement.getExportedLibrary().getDefiningCompilationUnit().getDisplayName(),
-            exportedLibrary.getDefiningCompilationUnit().getDisplayName());
+            prevElement.getLibrary().getDefiningCompilationUnit().getDisplayName(),
+            element.getLibrary().getDefiningCompilationUnit().getDisplayName());
         return true;
       } else {
-        exportedNames.put(name, exportElement);
+        exportedElements.put(name, element);
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
    * 
    * @param node the {@link ArgumentDefinitionTest} to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
@@ skipping 3643 matching lines @@
       if (superClassElt != null) {
         return memberHasConcreteMethodImplementationInSuperclassChain(
             superClassElt,
             methodName,
             superclassChain);
       }
     }
     return false;
   }
 }