Merge pull request #966 from paulp/issue/6117

SI-6117 regression involving import ambiguity. 

5 files changed, 52 insertions, 15 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/model/Links.scala b/src/compiler/scala/tools/nsc/doc/model/LinkTo.scala
index b76dee0f14..b76dee0f14 100644
--- a/src/compiler/scala/tools/nsc/doc/model/Links.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/LinkTo.scala
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 80e7d0d474..51753baa4f 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -4661,15 +4661,28 @@ trait Typers extends Modes with Adaptations with Tags {
                 // If the ambiguous name is a monomorphic type, we can relax this far.
                 def mt1 = t1 memberType impSym
                 def mt2 = t2 memberType impSym1
+                def characterize = List(
+                  s"types:  $t1 =:= $t2  ${t1 =:= t2}  members: ${mt1 =:= mt2}",
+                  s"member type 1: $mt1",
+                  s"member type 2: $mt2",
+                  s"$impSym == $impSym1  ${impSym == impSym1}",
+                  s"${impSym.debugLocationString} ${impSym.getClass}",
+                  s"${impSym1.debugLocationString} ${impSym1.getClass}"
+                ).mkString("\n  ")
+
+                // The symbol names are checked rather than the symbols themselves because
+                // each time an overloaded member is looked up it receives a new symbol.
+                // So foo.member("x") != foo.member("x") if x is overloaded.  This seems
+                // likely to be the cause of other bugs too...
+                if (t1 =:= t2 && impSym.name == impSym1.name)
+                  log(s"Suppressing ambiguous import: $t1 =:= $t2 && $impSym == $impSym1")
                 // Monomorphism restriction on types is in part because type aliases could have the
                 // same target type but attach different variance to the parameters. Maybe it can be
                 // relaxed, but doesn't seem worth it at present.
-                if (t1 =:= t2 && impSym == impSym1)
-                  log(s"Suppressing ambiguous import: $t1 =:= $t2 && $impSym == $impSym1")
                 else if (mt1 =:= mt2 && name.isTypeName && impSym.isMonomorphicType && impSym1.isMonomorphicType)
                   log(s"Suppressing ambiguous import: $mt1 =:= $mt2 && $impSym and $impSym1 are equivalent")
                 else {
-                  log(s"Import is genuinely ambiguous: !($t1 =:= $t2)")
+                  log(s"Import is genuinely ambiguous:\n  " + characterize)
                   ambiguousError(s"it is imported twice in the same scope by\n${imports.head}\nand ${imports1.head}")
                 }
               }
diff --git a/src/library/scala/reflect/ClassManifest.scala b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
index d226e43e77..d226e43e77 100644
--- a/src/library/scala/reflect/ClassManifest.scala
+++ b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala
diff --git a/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala b/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala
index 5fbeb5f576..cecf8e4658 100644
--- a/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala
+++ b/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala
@@ -8,7 +8,8 @@ trait TraceSymbolActivity {
   val global: SymbolTable
   import global._
 
-  if (traceSymbolActivity && global.isCompilerUniverse)
+  private[this] var enabled = traceSymbolActivity
+  if (enabled && global.isCompilerUniverse)
     scala.sys addShutdownHook showAllSymbols()
 
   private type Set[T] = scala.collection.immutable.Set[T]
@@ -21,23 +22,26 @@ trait TraceSymbolActivity {
   val allTrees    = mutable.Set[Tree]()
 
   def recordSymbolsInTree(tree: Tree) {
-    allTrees += tree
+    if (enabled)
+      allTrees += tree
   }
 
   def recordNewSymbol(sym: Symbol) {
-    if (sym.id > 1) {
+    if (enabled && sym.id > 1) {
       allSymbols(sym.id) = sym
       allChildren(sym.owner.id) ::= sym.id
     }
   }
   def recordNewSymbolOwner(sym: Symbol, newOwner: Symbol) {
-    val sid = sym.id
-    val oid = sym.owner.id
-    val nid = newOwner.id
-
-    prevOwners(sid) ::= (oid -> phase)
-    allChildren(oid) = allChildren(oid) filterNot (_ == sid)
-    allChildren(nid) ::= sid
+    if (enabled) {
+      val sid = sym.id
+      val oid = sym.owner.id
+      val nid = newOwner.id
+
+      prevOwners(sid) ::= (oid -> phase)
+      allChildren(oid) = allChildren(oid) filterNot (_ == sid)
+      allChildren(nid) ::= sid
+    }
   }
 
   /** TODO.
@@ -86,7 +90,7 @@ trait TraceSymbolActivity {
     def prefix = ("  " * (sym.ownerChain.length - 1)) + sym.id
     try println("%s#%s %s".format(prefix, sym.accurateKindString, sym.name.decode))
     catch {
-      case x => println(prefix + " failed: " + x)
+      case x: Throwable => println(prefix + " failed: " + x)
     }
     allChildren(sym.id).sorted foreach showIdAndRemove
   }
@@ -128,7 +132,8 @@ trait TraceSymbolActivity {
   private def runBeforeErasure[T](body: => T): T = atPhase(findErasurePhase)(body)
 
   def showAllSymbols() {
-    if (!traceSymbolActivity) return
+    if (!enabled) return
+    enabled = false
     allSymbols(1) = NoSymbol
 
     println("" + allSymbols.size + " symbols created.")
diff --git a/test/files/pos/t6117.scala b/test/files/pos/t6117.scala
new file mode 100644
index 0000000000..6aca84f72c
--- /dev/null
+++ b/test/files/pos/t6117.scala
@@ -0,0 +1,19 @@
+package test
+
+trait ImportMe {
+  def foo(i: Int) = 1
+  def foo(s: String) = 2
+}
+
+class Test(val importMe: ImportMe) {
+  import importMe._
+  import importMe._
+
+  // A.scala:12: error: reference to foo is ambiguous;
+  // it is imported twice in the same scope by
+  // import importMe._
+  // and import importMe._
+  //   println(foo(1))
+  //           ^
+  println(foo(1))
+}