Handle complicated imports.

pkg/front_end/lib/src/fasta/kernel/kernel_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.kernel_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import '../errors.dart' show internalError;
 
 import '../loader.dart' show Loader;
 
 import '../modifier.dart' show abstractMask, staticMask;
 
 import '../source/source_library_builder.dart'
     show DeclarationBuilder, SourceLibraryBuilder;
 
 import '../source/source_class_builder.dart' show SourceClassBuilder;
 
 import '../util/relativize.dart' show relativizeUri;
 
 import 'kernel_builder.dart'
     show
+        AccessErrorBuilder,
         Builder,
         BuiltinTypeBuilder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         FormalParameterBuilder,
         FunctionTypeAliasBuilder,
+        InvalidTypeBuilder,
         KernelConstructorBuilder,
         KernelEnumBuilder,
         KernelFieldBuilder,
         KernelFormalParameterBuilder,
         KernelFunctionTypeAliasBuilder,
         KernelFunctionTypeBuilder,
         KernelInvalidTypeBuilder,
         KernelMixinApplicationBuilder,
         KernelNamedMixinApplicationBuilder,
         KernelNamedTypeBuilder,
@@ skipping 276 matching lines @@
       internalError("Unhandled builder: ${builder.runtimeType}");
     }
   }
 
   Library build() {
     super.build();
     library.name = name;
     return library;
   }
 
+  @override
   Builder buildAmbiguousBuilder(
-      String name, Builder builder, Builder other, int charOffset) {
+      String name, Builder builder, Builder other, int charOffset,
+      {bool isExport: false, bool isImport: false}) {
+    if (builder == other) return builder;
+    if (builder is InvalidTypeBuilder) return builder;
+    if (other is InvalidTypeBuilder) return other;
+    if (builder is AccessErrorBuilder) {
+      AccessErrorBuilder error = builder;
+      builder = error.builder;
+    }
+    if (other is AccessErrorBuilder) {
+      AccessErrorBuilder error = other;
+      other = error.builder;
+    }
+    bool isLocal = false;
+    Builder preferred;
+    Uri uri;
+    Uri otherUri;
+    Uri preferredUri;
+    Uri hiddenUri;
+    if (members[name] == builder) {
+      isLocal = true;
+      preferred = builder;
+      hiddenUri = other.computeLibraryUri();
+    } else {
+      uri = builder.computeLibraryUri();
+      otherUri = other.computeLibraryUri();
+      if (otherUri?.scheme == "dart" && uri?.scheme != "dart") {
+        preferred = builder;
+        preferredUri = uri;
+        hiddenUri = otherUri;
+      } else if (uri?.scheme == "dart" && otherUri?.scheme != "dart") {
+        preferred = other;
+        preferredUri = otherUri;
+        hiddenUri = uri;
+      }
+    }
+    if (preferred != null) {
+      if (isLocal) {
+        if (isExport) {
+          addNit(charOffset,
+              "Local definition of '$name' hides export from '${hiddenUri}'.");
+        } else {
+          addNit(charOffset,
+              "Local definition of '$name' hides import from '${hiddenUri}'.");
+        }
+      } else {
+        if (isExport) {
+          addNit(
+              charOffset,
+              "Export of '$name' (from '${preferredUri}') hides export from "
+              "'${hiddenUri}'.");
+        } else {
+          addNit(
+              charOffset,
+              "Import of '$name' (from '${preferredUri}') hides import from "
+              "'${hiddenUri}'.");
+        }
+      }
+      return preferred;
+    }
     if (builder.next == null && other.next == null) {
       if (builder.isGetter && other.isSetter) {
         return new MixedAccessor(builder, other, this);
       } else if (builder.isSetter && other.isGetter) {
         return new MixedAccessor(other, builder, this);
       }
+      if (isImport && builder is PrefixBuilder && other is PrefixBuilder) {
+        // Handles the case where the same prefix is used for different
+        // imports.
+        PrefixBuilder prefix = builder;
+        other.exports.forEach((String name, Builder member) {
+          Builder existing = exports[name];
+          if (existing != null) {
+            if (existing != member) {
+              member = buildAmbiguousBuilder(name, existing, member, charOffset,
+                  isExport: isExport, isImport: isImport);
+            }
+          }
+          prefix.exports[name] = member;
+        });
+        return builder;
+      }
+    }
+    if (isExport) {
+      addNit(charOffset,
+          "'$name' is exported from both '${uri}' and '${otherUri}'.");
+    } else {
+      addNit(charOffset,
+          "'$name' is imported from both '${uri}' and '${otherUri}'.");
     }
     return new KernelInvalidTypeBuilder(name, charOffset, fileUri);
   }
 
   int finishStaticInvocations() {
     CloneVisitor cloner;
     for (var list in argumentsWithMissingDefaultValues) {
       final Arguments arguments = list[0];
       final FunctionNode function = list[1];
 
@@ skipping 81 matching lines @@
   }
 }
 
 bool isConstructorName(String name, String className) {
   if (name.startsWith(className)) {
     if (name.length == className.length) return true;
     if (name.startsWith(".", className.length)) return true;
   }
   return false;
 }