Revert "Scaladoc class diagrams part 1"

This reverts commit 831f09bb6d00c152bd8aef3ce8bf9e200080fe36.

15 files changed, 62 insertions, 476 deletions

diff --git a/test/scaladoc/resources/implicits-ambiguating-res.scala b/test/scaladoc/resources/implicits-ambiguating-res.scala
deleted file mode 100644
index 6ed51366cb..0000000000
--- a/test/scaladoc/resources/implicits-ambiguating-res.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- *  Test scaladoc implicits distinguishing -- supress all members by implicit conversion that are shadowed by the
- *  class' own members
- *
- *  {{{
- *     scala> class A { def foo(t: String) = 4 }
- *     defined class A
- *
- *     scala> class B { def foo(t: Any) = 5 }
- *     defined class B
- *
- *     scala> implicit def AtoB(a:A) = new B
- *     AtoB: (a: A)B
- *
- *     scala> val a = new A
- *     a: A = A@28f553e3
- *
- *     scala> a.foo("T")
- *     res1: Int = 4
- *
- *     scala> a.foo(4)
- *     res2: Int = 5
- *  }}}
- */
-package scala.test.scaladoc.implicits.ambiguating
-import language.implicitConversions // according to SIP18
-
-/** - conv1-5 should be ambiguous
- *  - conv6-7 should not be ambiguous
- *  - conv8 should be ambiguous
- *  - conv9 should be ambiguous
- *  - conv10 and conv11 should not be ambiguous */
-class A[T]
-/** conv1-9 should be the same, conv10 should be ambiguous, conv11 should be okay */
-class B extends A[Int]
-/** conv1-9 should be the same, conv10 and conv11 should not be ambiguous */
-class C extends A[Double]
-    /** conv1-9 should be the same, conv10 should not be ambiguous while conv11 should be ambiguous */
-class D extends A[AnyRef]
-
-class X[T] {
-  def conv1: AnyRef = ???
-  def conv2: T = ???
-  def conv3(l: Int): AnyRef = ???
-  def conv4(l: AnyRef): AnyRef = ???
-  def conv5(l: AnyRef): String = ???
-  def conv6(l: String)(m: String): AnyRef = ???
-  def conv7(l: AnyRef)(m: AnyRef): AnyRef = ???
-  def conv8(l: AnyRef): AnyRef = ???
-  def conv9(l: String): AnyRef = ???
-  def conv10(l: T): T = ???
-  def conv11(l: T): T = ???
-}
-
-class Z[T] {
-  def conv1: AnyRef = ???
-  def conv2: T = ???
-  def conv3(p: Int): AnyRef = ???
-  def conv4(p: AnyRef): String = ???
-  def conv5(p: AnyRef): AnyRef = ???
-  def conv6(p: String, q: String): AnyRef = ???
-  def conv7(p: AnyRef, q: AnyRef): AnyRef = ???
-  def conv8(p: String): AnyRef = ???
-  def conv9(p: AnyRef): AnyRef = ???
-  def conv10(p: Int): T = ???
-  def conv11(p: String): T = ???
-}
-
-object A {
-  implicit def AtoX[T](a: A[T]) = new X[T]
-  implicit def AtoZ[T](a: A[T]) = new Z[T]
-}
diff --git a/test/scaladoc/resources/implicits-base-res.scala b/test/scaladoc/resources/implicits-base-res.scala
index d6c0332c10..65d7bdf67c 100644
--- a/test/scaladoc/resources/implicits-base-res.scala
+++ b/test/scaladoc/resources/implicits-base-res.scala
@@ -16,9 +16,8 @@ trait MyNumeric[R]
  * def convToManifestA(x: T)              // pimpA7: with 2 constraints: T: Manifest and T <: Double
  * def convToMyNumericA(x: T)             // pimpA6: with a constraint that there is x: MyNumeric[T] implicit in scope
  * def convToNumericA(x: T)               // pimpA1: with a constraint that there is x: Numeric[T] implicit in scope
- * def convToPimpedA(x: Bar[Foo[T]])      // pimpA5: no constraints, SHADOWED
- * def convToPimpedA(x: S)                // pimpA4: with 3 constraints: T = Foo[Bar[S]], S: Foo and S: Bar, SHADOWED
- * def convToPimpedA(x: T)                // pimpA0: with no constraints, SHADOWED
+ * def convToPimpedA(x: Bar[Foo[T]])      // pimpA5: no constraints
+ * def convToPimpedA(x: S)                // pimpA4: with 3 constraints: T = Foo[Bar[S]], S: Foo and S: Bar
  * def convToTraversableOps(x: T)         // pimpA7: with 2 constraints: T: Manifest and T <: Double
  *                                        // should not be abstract!
  * }}}
@@ -53,10 +52,9 @@ object A {
  * def convToManifestA(x: Double)         // pimpA7: no constraints
  * def convToMyNumericA(x: Double)        // pimpA6: (if showAll is set) with a constraint that there is x: MyNumeric[Double] implicit in scope
  * def convToNumericA(x: Double)          // pimpA1: no constraintsd
- * def convToPimpedA(x: Bar[Foo[Double]]) // pimpA5: no constraints, SHADOWED
- * def convToPimpedA(x: Double)           // pimpA0: no constraints, SHADOWED
+ * def convToPimpedA(x: Bar[Foo[Double]]) // pimpA5: no constraints
  * def convToTraversableOps(x: Double)    // pimpA7: no constraints
- *                                        // should not be abstract!
+ *                                       // should not be abstract!
  * }}}
  */
 class B extends A[Double]
@@ -70,8 +68,7 @@ object B extends A
  * def convToIntA(x: Int)                 // pimpA2: no constraints
  * def convToMyNumericA(x: Int)           // pimpA6: (if showAll is set) with a constraint that there is x: MyNumeric[Int] implicit in scope
  * def convToNumericA(x: Int)             // pimpA1: no constraints
- * def convToPimpedA(x: Int)              // pimpA0: no constraints, SHADOWED
- * def convToPimpedA(x: Bar[Foo[Int]])    // pimpA5: no constraints, SHADOWED
+ * def convToPimpedA(x: Bar[Foo[Int]])    // pimpA5: no constraints
  * }}}
  */
 class C extends A[Int]
@@ -84,8 +81,7 @@ object C extends A
  * {{{
  * def convToMyNumericA(x: String)        // pimpA6: (if showAll is set) with a constraint that there is x: MyNumeric[String] implicit in scope
  * def convToNumericA(x: String)          // pimpA1: (if showAll is set) with a constraint that there is x: Numeric[String] implicit in scope
- * def convToPimpedA(x: Bar[Foo[String]]) // pimpA5: no constraints, SHADOWED
- * def convToPimpedA(x: String)           // pimpA0: no constraints, SHADOWED
+ * def convToPimpedA(x: Bar[Foo[String]]) // pimpA5: no constraints
  * }}}
  */
 class D extends A[String]
diff --git a/test/scaladoc/resources/implicits-elimination-res.scala b/test/scaladoc/resources/implicits-elimination-res.scala
index 5f7135c9e8..b23667440c 100644
--- a/test/scaladoc/resources/implicits-elimination-res.scala
+++ b/test/scaladoc/resources/implicits-elimination-res.scala
@@ -2,13 +2,13 @@
  *  Testing scaladoc implicits elimination
  */
 package scala.test.scaladoc.implicits.elimination {
-
+  
   import language.implicitConversions // according to SIP18
 
   /** No conversion, as B doesn't bring any member */
   class A
   class B { class C; trait V; type T; }
-  object A {
-  	implicit def toB(a: A): B = null
+  object A { 
+  	implicit def toB(a: A): B = null 
   }
 }
diff --git a/test/scaladoc/run/diagrams-base.scala b/test/scaladoc/run/diagrams-base.scala
deleted file mode 100644
index 38bed06502..0000000000
--- a/test/scaladoc/run/diagrams-base.scala
+++ /dev/null
@@ -1,73 +0,0 @@
-import scala.tools.nsc.doc.model._
-import scala.tools.nsc.doc.model.diagram._
-import scala.tools.partest.ScaladocModelTest
-
-object Test extends ScaladocModelTest {
-
-  override def code = """
-      package scala.test.scaladoc.diagrams
-
-      import language.implicitConversions
-
-      trait A
-      trait B
-      trait C
-      class E extends A with B with C
-      object E { implicit def eToT(e: E) = new T }
-
-      class F extends E
-      class G extends E
-      private class H extends E /* since it's private, it won't go into the diagram */
-      class T { def t = true }
-
-      class X
-      object X { implicit def xToE(x: X) = new E}
-      class Y extends X
-      class Z
-      object Z { implicit def zToE(z: Z) = new E}
-    """
-
-  // diagrams must be started. In case there's an error with dot, it should not report anything
-  def scaladocSettings = "-diagrams -implicits"
-
-  def testModel(rootPackage: Package) = {
-    // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
-    import access._
-
-    val base = rootPackage._package("scala")._package("test")._package("scaladoc")._package("diagrams")
-    val E = base._class("E")
-    val diag = E.inheritanceDiagram.get
-
-    // there must be a single this node
-    assert(diag.nodes.filter(_.isThisNode).length == 1)
-
-    // 1. check class E diagram
-    assert(diag.isClassDiagram)
-
-    val (incoming, outgoing) = diag.edges.partition(!_._1.isThisNode)
-    assert(incoming.length == 5)
-    assert(outgoing.head._2.length == 4)
-
-    val (outgoingSuperclass, outgoingImplicit) = outgoing.head._2.partition(_.isNormalNode)
-    assert(outgoingSuperclass.length == 3)
-    assert(outgoingImplicit.length == 1)
-
-    val (incomingSubclass, incomingImplicit) = incoming.partition(_._1.isNormalNode)
-    assert(incomingSubclass.length == 2)
-    assert(incomingImplicit.length == 3)
-
-    val classDiag = diag.asInstanceOf[ClassDiagram]
-    assert(classDiag.incomingImplicits.length == 3)
-    assert(classDiag.outgoingImplicits.length == 1)
-
-    // 2. check package diagram
-    // NOTE: Z should be eliminated because it's isolated
-    val packDiag = base.contentDiagram.get
-    assert(packDiag.isPackageDiagram)
-    assert(packDiag.nodes.length == 8) // check singular object removal
-    assert(packDiag.edges.length == 4)
-    assert(packDiag.edges.foldLeft(0)(_ + _._2.length) == 6)
-
-    // TODO: Should check numbering
-  }
-}
\ No newline at end of file
diff --git a/test/scaladoc/run/diagrams-determinism.check b/test/scaladoc/run/diagrams-determinism.check
deleted file mode 100644
index 619c56180b..0000000000
--- a/test/scaladoc/run/diagrams-determinism.check
+++ /dev/null
@@ -1 +0,0 @@
-Done.
diff --git a/test/scaladoc/run/diagrams-determinism.scala b/test/scaladoc/run/diagrams-determinism.scala
deleted file mode 100644
index 6c8db05d78..0000000000
--- a/test/scaladoc/run/diagrams-determinism.scala
+++ /dev/null
@@ -1,67 +0,0 @@
-import scala.tools.nsc.doc.model._
-import scala.tools.nsc.doc.model.diagram._
-import scala.tools.partest.ScaladocModelTest
-
-object Test extends ScaladocModelTest {
-
-  override def code = """
-      package scala.test.scaladoc.diagrams
-
-      trait A
-      trait B extends A
-      trait C extends B
-      trait D extends C with A
-      trait E extends C with A with D
-    """
-
-  // diagrams must be started. In case there's an error with dot, it should not report anything
-  def scaladocSettings = "-diagrams -implicits"
-
-  def testModel(rootPackage: Package) = {
-    // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
-    import access._
-
-    def diagramString(rootPackage: Package) = {
-      val base = rootPackage._package("scala")._package("test")._package("scaladoc")._package("diagrams")
-      val A = base._trait("A")
-      val B = base._trait("B")
-      val C = base._trait("C")
-      val D = base._trait("D")
-      val E = base._trait("E")
-
-      base.contentDiagram.get.toString + "\n" +
-         A.inheritanceDiagram.get.toString + "\n" +
-         B.inheritanceDiagram.get.toString + "\n" +
-         C.inheritanceDiagram.get.toString + "\n" +
-         D.inheritanceDiagram.get.toString + "\n" +
-         E.inheritanceDiagram.get.toString
-    }
-
-    // 1. check that several runs produce the same output
-    val run0 = diagramString(rootPackage)
-    val run1 = diagramString(model.getOrElse({sys.error("Scaladoc Model Test ERROR: No universe generated!")}).rootPackage)
-    val run2 = diagramString(model.getOrElse({sys.error("Scaladoc Model Test ERROR: No universe generated!")}).rootPackage)
-    val run3 = diagramString(model.getOrElse({sys.error("Scaladoc Model Test ERROR: No universe generated!")}).rootPackage)
-
-    // any variance in the order of the diagram elements should crash the following tests:
-    assert(run0 == run1)
-    assert(run1 == run2)
-    assert(run2 == run3)
-
-    // 2. check the order in the diagram: this node, subclasses, and then implicit conversions
-    def assertRightOrder(diagram: Diagram) = {
-      for ((node, subclasses) <- diagram.edges)
-        assert(subclasses == subclasses.filter(_.isThisNode) :::
-                             subclasses.filter(_.isNormalNode) :::
-                             subclasses.filter(_.isImplicitNode))
-    }
-
-    val base = rootPackage._package("scala")._package("test")._package("scaladoc")._package("diagrams")
-    assertRightOrder(base.contentDiagram.get)
-    assertRightOrder(base._trait("A").inheritanceDiagram.get)
-    assertRightOrder(base._trait("B").inheritanceDiagram.get)
-    assertRightOrder(base._trait("C").inheritanceDiagram.get)
-    assertRightOrder(base._trait("D").inheritanceDiagram.get)
-    assertRightOrder(base._trait("E").inheritanceDiagram.get)
-  }
-}
\ No newline at end of file
diff --git a/test/scaladoc/run/diagrams-filtering.check b/test/scaladoc/run/diagrams-filtering.check
deleted file mode 100644
index 619c56180b..0000000000
--- a/test/scaladoc/run/diagrams-filtering.check
+++ /dev/null
@@ -1 +0,0 @@
-Done.
diff --git a/test/scaladoc/run/diagrams-filtering.scala b/test/scaladoc/run/diagrams-filtering.scala
deleted file mode 100644
index dfde5cac52..0000000000
--- a/test/scaladoc/run/diagrams-filtering.scala
+++ /dev/null
@@ -1,93 +0,0 @@
-import scala.tools.nsc.doc.model._
-import scala.tools.nsc.doc.model.diagram._
-import scala.tools.partest.ScaladocModelTest
-
-object Test extends ScaladocModelTest {
-
-  override def code = """
-        package scala.test.scaladoc
-
-        /** @contentDiagram hideNodes "scala.test.*.A" "java.*", hideEdges ("*G" -> "*E") */
-        package object diagrams {
-          def foo = 4
-        }
-
-        package diagrams {
-          import language.implicitConversions
-
-          /** @inheritanceDiagram hideIncomingImplicits, hideNodes "*E" */
-          trait A
-          trait AA extends A
-          trait B
-          trait AAA extends B
-
-          /** @inheritanceDiagram hideDiagram */
-          trait C
-          trait AAAA extends C
-
-          /** @inheritanceDiagram hideEdges("*E" -> "*A") */
-          class E extends A with B with C
-          class F extends E
-          /** @inheritanceDiagram hideNodes "*G" "G" */
-          class G extends E
-          private class H extends E /* since it's private, it won't go into the diagram */
-          class T { def t = true }
-          object E {
-            implicit def eToT(e: E) = new T
-            implicit def eToA(e: E) = new A { }
-          }
-        }
-    """
-
-  // diagrams must be started. In case there's an error with dot, it should not report anything
-  def scaladocSettings = "-diagrams -implicits"
-
-  def testModel(rootPackage: Package) = {
-    // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
-    import access._
-
-    // base package
-    // Assert we have 7 nodes and 6 edges
-    val base = rootPackage._package("scala")._package("test")._package("scaladoc")._package("diagrams")
-    val packDiag = base.contentDiagram.get
-    assert(packDiag.nodes.length == 6)
-    assert(packDiag.edges.map(_._2.length).sum == 5)
-
-    // trait A
-    // Assert we have just 2 nodes and 1 edge
-    val A = base._trait("A")
-    val ADiag = A.inheritanceDiagram.get
-    assert(ADiag.nodes.length == 2)
-    assert(ADiag.edges.map(_._2.length).sum == 1)
-
-    // trait C
-    val C = base._trait("C")
-    assert(!C.inheritanceDiagram.isDefined)
-
-    // trait G
-    val G = base._trait("G")
-    assert(!G.inheritanceDiagram.isDefined)
-
-    // trait E
-    val E = base._class("E")
-    val EDiag = E.inheritanceDiagram.get
-
-    // there must be a single this node
-    assert(EDiag.nodes.filter(_.isThisNode).length == 1)
-
-    // 1. check class E diagram
-    val (incoming, outgoing) = EDiag.edges.partition(!_._1.isThisNode)
-    assert(incoming.length == 2) // F and G
-    assert(outgoing.head._2.length == 3) // B, C and T
-
-    val (outgoingSuperclass, outgoingImplicit) = outgoing.head._2.partition(_.isNormalNode)
-    assert(outgoingSuperclass.length == 2) // B and C
-    assert(outgoingImplicit.length == 1) // T
-
-    val (incomingSubclass, incomingImplicit) = incoming.partition(_._1.isNormalNode)
-    assert(incomingSubclass.length == 2) // F and G
-    assert(incomingImplicit.length == 0)
-
-    assert(EDiag.nodes.length == 6) // E, B and C, F and G and the implicit conversion to T
-  }
-}
\ No newline at end of file
diff --git a/test/scaladoc/run/implicits-ambiguating.check b/test/scaladoc/run/implicits-ambiguating.check
deleted file mode 100644
index 619c56180b..0000000000
--- a/test/scaladoc/run/implicits-ambiguating.check
+++ /dev/null
@@ -1 +0,0 @@
-Done.
diff --git a/test/scaladoc/run/implicits-ambiguating.scala b/test/scaladoc/run/implicits-ambiguating.scala
deleted file mode 100644
index 19e0f72b7b..0000000000
--- a/test/scaladoc/run/implicits-ambiguating.scala
+++ /dev/null
@@ -1,111 +0,0 @@
-import scala.tools.nsc.doc.model._
-import scala.tools.partest.ScaladocModelTest
-
-object Test extends ScaladocModelTest {
-
-  // test a file instead of a piece of code
-  override def resourceFile = "implicits-ambiguating-res.scala"
-
-  // start implicits
-  def scaladocSettings = "-implicits"
-
-  def testModel(root: Package) = {
-    // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
-    import access._
-
-    // SEE THE test/resources/implicits-chaining-res.scala FOR THE EXPLANATION OF WHAT'S CHECKED HERE:
-    val base = root._package("scala")._package("test")._package("scaladoc")._package("implicits")._object("ambiguating")
-    var conv1: ImplicitConversion = null
-    var conv2: ImplicitConversion = null
-
-//// class A ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    val A = base._class("A")
-
-    conv1 = A._conversion(base._object("A").qualifiedName + ".AtoX")
-    conv2 = A._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv1.members.length == 11)
-    assert(conv2.members.length == 11)
-    assert(conv1.constraints.length == 0)
-    assert(conv2.constraints.length == 0)
-
-    /** - conv1-5 should be ambiguous
-     *  - conv6-7 should not be ambiguous
-     *  - conv8 should be ambiguous
-     *  - conv9 should be ambiguous
-     *  - conv10 and conv11 should not be ambiguous */
-    def check1to9(cls: String): Unit = {
-      for (conv <- (1 to 5).map("conv" + _)) {
-        assert(conv1._member(conv).byConversion.get.isAmbiguous, cls + " - AtoX." + conv + " is ambiguous")
-        assert(conv2._member(conv).byConversion.get.isAmbiguous, cls + " - AtoZ." + conv + " is ambiguous")
-      }
-      for (conv <- (6 to 7).map("conv" + _)) {
-        assert(!conv1._member(conv).byConversion.get.isAmbiguous, cls + " - AtoX." + conv + " is not ambiguous")
-        assert(!conv2._member(conv).byConversion.get.isAmbiguous, cls + " - AtoZ." + conv + " is not ambiguous")
-      }
-      assert(conv1._member("conv8").byConversion.get.isAmbiguous, cls + " - AtoX.conv8 is ambiguous")
-      assert(conv2._member("conv8").byConversion.get.isAmbiguous, cls + " - AtoZ.conv8 is ambiguous")
-      assert(conv1._member("conv9").byConversion.get.isAmbiguous, cls + " - AtoX.conv9 is ambiguous")
-      assert(conv2._member("conv9").byConversion.get.isAmbiguous, cls + " - AtoZ.conv9 is ambiguous")
-    }
-    check1to9("A")
-    assert(!conv1._member("conv10").byConversion.get.isAmbiguous, "A - AtoX.conv10 is not ambiguous")
-    assert(!conv2._member("conv10").byConversion.get.isAmbiguous, "A - AtoZ.conv10 is not ambiguous")
-    assert(!conv1._member("conv11").byConversion.get.isAmbiguous, "A - AtoX.conv11 is not ambiguous")
-    assert(!conv2._member("conv11").byConversion.get.isAmbiguous, "A - AtoZ.conv11 is not ambiguous")
-
-//// class B ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    val B = base._class("B")
-
-    conv1 = B._conversion(base._object("A").qualifiedName + ".AtoX")
-    conv2 = B._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv1.members.length == 11)
-    assert(conv2.members.length == 11)
-    assert(conv1.constraints.length == 0)
-    assert(conv2.constraints.length == 0)
-
-    /** conv1-9 should be the same, conv10 should be ambiguous, conv11 should be okay */
-    check1to9("B")
-    assert(conv1._member("conv10").byConversion.get.isAmbiguous, "B - AtoX.conv10 is ambiguous")
-    assert(conv2._member("conv10").byConversion.get.isAmbiguous, "B - AtoZ.conv10 is ambiguous")
-    assert(!conv1._member("conv11").byConversion.get.isAmbiguous, "B - AtoX.conv11 is not ambiguous")
-    assert(!conv2._member("conv11").byConversion.get.isAmbiguous, "B - AtoZ.conv11 is not ambiguous")
-
-//// class C ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    val C = base._class("C")
-
-    conv1 = C._conversion(base._object("A").qualifiedName + ".AtoX")
-    conv2 = C._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv1.members.length == 11)
-    assert(conv2.members.length == 11)
-    assert(conv1.constraints.length == 0)
-    assert(conv2.constraints.length == 0)
-
-    /** conv1-9 should be the same, conv10 and conv11 should not be ambiguous */
-    check1to9("C")
-    assert(!conv1._member("conv10").byConversion.get.isAmbiguous, "C - AtoX.conv10 is not ambiguous")
-    assert(!conv2._member("conv10").byConversion.get.isAmbiguous, "C - AtoZ.conv10 is not ambiguous")
-    assert(!conv1._member("conv11").byConversion.get.isAmbiguous, "C - AtoX.conv11 is not ambiguous")
-    assert(!conv2._member("conv11").byConversion.get.isAmbiguous, "C - AtoZ.conv11 is not ambiguous")
-
-//// class D ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    val D = base._class("D")
-
-    conv1 = D._conversion(base._object("A").qualifiedName + ".AtoX")
-    conv2 = D._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv1.members.length == 11)
-    assert(conv2.members.length == 11)
-    assert(conv1.constraints.length == 0)
-    assert(conv2.constraints.length == 0)
-
-    /** conv1-9 should be the same, conv10 should not be ambiguous while conv11 should be ambiguous */
-    check1to9("D")
-    assert(!conv1._member("conv10").byConversion.get.isAmbiguous, "D - AtoX.conv10 is not ambiguous")
-    assert(!conv2._member("conv10").byConversion.get.isAmbiguous, "D - AtoZ.conv10 is not ambiguous")
-    assert(conv1._member("conv11").byConversion.get.isAmbiguous, "D - AtoX.conv11 is ambiguous")
-    assert(conv2._member("conv11").byConversion.get.isAmbiguous, "D - AtoZ.conv11 is ambiguous")
-  }
-}
\ No newline at end of file
diff --git a/test/scaladoc/run/implicits-base.scala b/test/scaladoc/run/implicits-base.scala
index ce2d025511..06d017ed70 100644
--- a/test/scaladoc/run/implicits-base.scala
+++ b/test/scaladoc/run/implicits-base.scala
@@ -22,12 +22,8 @@ object Test extends ScaladocModelTest {
 
     val A = base._class("A")
 
-    // def convToPimpedA(x: T)                // pimpA0: with no constraints, SHADOWED
-    conv = A._conversion(A.qualifiedName + ".pimpA0")
-    assert(conv.members.length == 1)
-    assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
-    assert(conv._member("convToPimpedA").resultType.name == "T")
+    // the method pimped on by pimpA0 should be shadowed by the method in class A
+    assert(A._conversions(A.qualifiedName + ".pimpA0").isEmpty)
 
     // def convToNumericA: T               // pimpA1: with a constraint that there is x: Numeric[T] implicit in scope
     conv = A._conversion(A.qualifiedName + ".pimpA1")
@@ -57,7 +53,6 @@ object Test extends ScaladocModelTest {
     conv = A._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
     assert(conv._member("convToPimpedA").resultType.name == "Bar[Foo[T]]")
 
     // def convToMyNumericA: T             // pimpA6: with a constraint that there is x: MyNumeric[T] implicit in scope
@@ -81,16 +76,10 @@ object Test extends ScaladocModelTest {
     val B = base._class("B")
 
     // these conversions should not affect B
+    assert(B._conversions(A.qualifiedName + ".pimpA0").isEmpty)
     assert(B._conversions(A.qualifiedName + ".pimpA2").isEmpty)
     assert(B._conversions(A.qualifiedName + ".pimpA4").isEmpty)
 
-    // def convToPimpedA(x: Double)           // pimpA0: no constraints, SHADOWED
-    conv = B._conversion(A.qualifiedName + ".pimpA0")
-    assert(conv.members.length == 1)
-    assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
-    assert(conv._member("convToPimpedA").resultType.name == "Double")
-
     // def convToNumericA: Double          // pimpA1: no constraintsd
     conv = B._conversion(A.qualifiedName + ".pimpA1")
     assert(conv.members.length == 1)
@@ -107,7 +96,6 @@ object Test extends ScaladocModelTest {
     conv = B._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
     assert(conv._member("convToPimpedA").resultType.name == "Bar[Foo[Double]]")
 
     // def convToMyNumericA: Double        // pimpA6: (if showAll is set) with a constraint that there is x: MyNumeric[Double] implicit in scope
@@ -131,17 +119,11 @@ object Test extends ScaladocModelTest {
     val C = base._class("C")
 
     // these conversions should not affect C
+    assert(C._conversions(A.qualifiedName + ".pimpA0").isEmpty)
     assert(C._conversions(A.qualifiedName + ".pimpA3").isEmpty)
     assert(C._conversions(A.qualifiedName + ".pimpA4").isEmpty)
     assert(C._conversions(A.qualifiedName + ".pimpA7").isEmpty)
 
-    // def convToPimpedA(x: Int)           // pimpA0: no constraints, SHADOWED
-    conv = C._conversion(A.qualifiedName + ".pimpA0")
-    assert(conv.members.length == 1)
-    assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
-    assert(conv._member("convToPimpedA").resultType.name == "Int")
-
     // def convToNumericA: Int             // pimpA1: no constraints
     conv = C._conversion(A.qualifiedName + ".pimpA1")
     assert(conv.members.length == 1)
@@ -158,7 +140,6 @@ object Test extends ScaladocModelTest {
     conv = C._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
     assert(conv._member("convToPimpedA").resultType.name == "Bar[Foo[Int]]")
 
     // def convToMyNumericA: Int           // pimpA6: (if showAll is set) with a constraint that there is x: MyNumeric[Int] implicit in scope
@@ -172,18 +153,12 @@ object Test extends ScaladocModelTest {
     val D = base._class("D")
 
     // these conversions should not affect D
+    assert(D._conversions(A.qualifiedName + ".pimpA0").isEmpty)
     assert(D._conversions(A.qualifiedName + ".pimpA2").isEmpty)
     assert(D._conversions(A.qualifiedName + ".pimpA3").isEmpty)
     assert(D._conversions(A.qualifiedName + ".pimpA4").isEmpty)
     assert(D._conversions(A.qualifiedName + ".pimpA7").isEmpty)
 
-    // def convToPimpedA(x: String)        // pimpA0: no constraints, SHADOWED
-    conv = D._conversion(A.qualifiedName + ".pimpA0")
-    assert(conv.members.length == 1)
-    assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
-    assert(conv._member("convToPimpedA").resultType.name == "String")
-
     // def convToNumericA: String          // pimpA1: (if showAll is set) with a constraint that there is x: Numeric[String] implicit in scope
     conv = D._conversion(A.qualifiedName + ".pimpA1")
     assert(conv.members.length == 1)
@@ -194,7 +169,6 @@ object Test extends ScaladocModelTest {
     conv = D._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
-    assert(conv._member("convToPimpedA").byConversion.get.isShadowed)
     assert(conv._member("convToPimpedA").resultType.name == "Bar[Foo[String]]")
 
     // def convToMyNumericA: String        // pimpA6: (if showAll is set) with a constraint that there is x: MyNumeric[String] implicit in scope
diff --git a/test/scaladoc/run/diagrams-base.check b/test/scaladoc/run/implicits-elimination.check
index 619c56180b..619c56180b 100644
--- a/test/scaladoc/run/diagrams-base.check
+++ b/test/scaladoc/run/implicits-elimination.check
diff --git a/test/scaladoc/run/implicits-elimination.scala b/test/scaladoc/run/implicits-elimination.scala
new file mode 100644
index 0000000000..ed37b9cd90
--- /dev/null
+++ b/test/scaladoc/run/implicits-elimination.scala
@@ -0,0 +1,23 @@
+import scala.tools.nsc.doc.model._
+import scala.tools.partest.ScaladocModelTest
+import language._
+
+object Test extends ScaladocModelTest {
+
+  // test a file instead of a piece of code
+  override def resourceFile = "implicits-elimination-res.scala"
+
+  // start implicits
+  def scaladocSettings = "-implicits"
+
+  def testModel(root: Package) = {
+    // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
+    import access._
+
+    // SEE THE test/resources/implicits-elimination-res.scala FOR THE EXPLANATION OF WHAT'S CHECKED HERE:
+    val base = root._package("scala")._package("test")._package("scaladoc")._package("implicits")._package("elimination")
+    val A = base._class("A")
+
+    assert(A._conversions(A.qualifiedName + ".toB").isEmpty)
+  }
+}
diff --git a/test/scaladoc/run/implicits-shadowing.scala b/test/scaladoc/run/implicits-shadowing.scala
index f8a016fac9..7835223d21 100644
--- a/test/scaladoc/run/implicits-shadowing.scala
+++ b/test/scaladoc/run/implicits-shadowing.scala
@@ -22,8 +22,12 @@ object Test extends ScaladocModelTest {
     val A = base._class("A")
 
     conv = A._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 11)
-    assert(conv.members.forall(_.byConversion.get.isShadowed))
+    assert(conv.members.length == 5)
+    conv._member("conv5")
+    conv._member("conv8")
+    conv._member("conv9")
+    conv._member("conv10")
+    conv._member("conv11")
     assert(conv.constraints.length == 0)
 
 //// class B ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -31,8 +35,11 @@ object Test extends ScaladocModelTest {
     val B = base._class("B")
 
     conv = B._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 11)
-    assert(conv.members.forall(_.byConversion.get.isShadowed))
+    assert(conv.members.length == 4)
+    conv._member("conv5")
+    conv._member("conv8")
+    conv._member("conv9")
+    conv._member("conv11")
     assert(conv.constraints.length == 0)
 
 //// class C ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -40,8 +47,12 @@ object Test extends ScaladocModelTest {
     val C = base._class("C")
 
     conv = C._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 11)
-    assert(conv.members.forall(_.byConversion.get.isShadowed))
+    assert(conv.members.length == 5)
+    conv._member("conv5")
+    conv._member("conv8")
+    conv._member("conv9")
+    conv._member("conv10")
+    conv._member("conv11")
     assert(conv.constraints.length == 0)
 
 //// class D ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -49,8 +60,11 @@ object Test extends ScaladocModelTest {
     val D = base._class("D")
 
     conv = D._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 11)
-    assert(conv.members.forall(_.byConversion.get.isShadowed))
+    assert(conv.members.length == 4)
+    conv._member("conv5")
+    conv._member("conv8")
+    conv._member("conv9")
+    conv._member("conv10")
     assert(conv.constraints.length == 0)
   }
-}
+}
\ No newline at end of file
diff --git a/test/scaladoc/scalacheck/CommentFactoryTest.scala b/test/scaladoc/scalacheck/CommentFactoryTest.scala
index b576ba5544..68ca68efdd 100644
--- a/test/scaladoc/scalacheck/CommentFactoryTest.scala
+++ b/test/scaladoc/scalacheck/CommentFactoryTest.scala
@@ -5,12 +5,10 @@ import scala.tools.nsc.Global
 import scala.tools.nsc.doc
 import scala.tools.nsc.doc.model._
 import scala.tools.nsc.doc.model.comment._
-import scala.tools.nsc.doc.model._
-import scala.tools.nsc.doc.model.diagram._
 
 class Factory(val g: Global, val s: doc.Settings)
   extends doc.model.ModelFactory(g, s) {
-  thisFactory: Factory with ModelFactoryImplicitSupport with DiagramFactory with CommentFactory with doc.model.TreeFactory =>
+  thisFactory: Factory with ModelFactoryImplicitSupport with CommentFactory with doc.model.TreeFactory =>
 
   def strip(c: Comment): Option[Inline] = {
     c.body match {
@@ -31,7 +29,7 @@ object Test extends Properties("CommentFactory") {
     val settings = new doc.Settings((str: String) => {})
     val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings)
     val g = new Global(settings, reporter)
-    (new Factory(g, settings) with ModelFactoryImplicitSupport with DiagramFactory with CommentFactory with doc.model.TreeFactory)
+    (new Factory(g, settings) with ModelFactoryImplicitSupport with CommentFactory with doc.model.TreeFactory)
   }
 
   def parse(src: String, dst: Inline) = {