Handle complicated imports.

pkg/front_end/lib/src/fasta/source/source_library_builder.dart

 // Copyright (c) 2016, 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 fasta.source_library_builder;
 
 import 'package:kernel/ast.dart' show AsyncMarker, ProcedureKind;
 
 import '../combinator.dart' show Combinator;
 
@@ skipping 255 matching lines @@
     }
     Map<String, Builder> members = currentDeclaration.members;
     Builder existing = members[name];
     builder.next = existing;
     if (builder is PrefixBuilder && existing is PrefixBuilder) {
       assert(existing.next == null);
       builder.exports.forEach((String name, Builder builder) {
         Builder other = existing.exports.putIfAbsent(name, () => builder);
         if (other != builder) {
           existing.exports[name] =
-              other.combineAmbiguousImport(name, builder, this);
+              buildAmbiguousBuilder(name, other, builder, charOffset);
         }
       });
       return existing;
     } else if (isDuplicatedDefinition(existing, builder)) {
       addCompileTimeError(charOffset, "Duplicated definition of '$name'.");
     }
     return members[name] = builder;
   }
 
   bool isDuplicatedDefinition(Builder existing, Builder other) {
@@ skipping 89 matching lines @@
       addBuilder(name, builder, builder.charOffset);
     });
     types.addAll(part.types);
     constructorReferences.addAll(part.constructorReferences);
     part.partOfLibrary = this;
     // TODO(ahe): Include metadata from part?
   }
 
   void buildInitialScopes() {
     members.forEach(addToExportScope);
-    members.forEach(addToScope);
+    members.forEach((String name, Builder member) {
+      addToScope(name, member, member.charOffset, false);
+    });
   }
 
   void addImportsToScope() {
     bool explicitCoreImport = this == loader.coreLibrary;
     for (Import import in imports) {
       if (import.imported == loader.coreLibrary) {
         explicitCoreImport = true;
       }
       import.finalizeImports(this);
     }
     if (!explicitCoreImport) {
-      loader.coreLibrary.exports.forEach(addToScope);
+      loader.coreLibrary.exports.forEach((String name, Builder member) {
+        addToScope(name, member, -1, true);
+      });
     }
   }
 
-  void addToScope(String name, Builder member) {
+  @override
+  void addToScope(String name, Builder member, int charOffset, bool isImport) {
     Builder existing = scope.lookup(name, member.charOffset, fileUri);
     if (existing != null) {
       if (existing != member) {
-        scope.local[name] = existing.combineAmbiguousImport(name, member, this);
+        scope.local[name] = buildAmbiguousBuilder(
+            name, existing, member, charOffset,
+            isImport: isImport);
       }
-      // TODO(ahe): handle duplicated names.
     } else {
       scope.local[name] = member;
     }
   }
 
   /// Returns true if the export scope was modified.
   bool addToExportScope(String name, Builder member) {
     if (name.startsWith("_")) return false;
     if (member is PrefixBuilder) return false;
     Builder existing = exports[name];
     if (existing == member) return false;
     if (existing != null) {
-      exports[name] = buildAmbiguousBuilder(name, existing, member, -1);
+      Builder result =
+          buildAmbiguousBuilder(name, existing, member, -1, isExport: true);
+      exports[name] = result;
+      return result != existing;
     } else {
       exports[name] = member;
     }
     return true;
   }
 
   int resolveTypes(_) {
     int typeCount = types.length;
     for (T t in types) {
       t.resolveIn(scope);
@@ skipping 95 matching lines @@
   }
 
   /// Called to register [procedure] as a factory whose types are collected in
   /// [factoryDeclaration]. Later, once the class has been built, we can
   /// synthesize type variables on the factory matching the class'.
   void addFactoryDeclaration(
       ProcedureBuilder procedure, DeclarationBuilder<T> factoryDeclaration) {
     factoryDeclarations[procedure] = factoryDeclaration;
   }
 }