Scaladoc class diagrams part 1

This commit contains model changes required for adding class diagrams
to scaladoc. It also contains an improved implicit shadowing
computation, which hides the shadowed implicitly inherited members
from the main view and gives instructions on how to access them.

This is joint work with Damien Obrist (@damienobrist) on supporting
diagram generation in scaladoc, as part of Damien's semester project
in the LAMP laborarory at EPFL.

The full history is located at:
https://github.com/damienobrist/scala/tree/feature/diagrams-dev

Commit summary:

 - diagrams model
   - diagram settings (Settings.scala, ScalaDoc.scala)
   - diagram model object (Entity.scala, Diagram.scala)
   - model: tracking direct superclasses and subclasses,
     implicit conversions from and to (ModelFactory.scala)
   - diagram object computation (DiagramFactory.scala, DocFactory.scala)
   - capacity to filter diagrams (CommentFactory.scala,
     DiagramDirectiveParser.scala)
   - diagram statistics object (DiagramStats.scala)
   - delayed link evaluation (Body.scala, Comment.scala)
   - tests

 - improved implicits shadowing information
   - model shadowing computation (ModelFactoryImplicitSupport.scala,
     Entity.scala)
   - html generation for shadowing information (Template.scala)
   - tests

Also fixes an issue reported by @dragos, where single-line comment
expansion would lead to the comment disappearing.

Review by @kzys, @pedrofurla.

Adapted to the new model and fixed a couple of problems:
 - duplicate implicit conversions in StringAdd/StringFormat
 - incorrect implicit conversion signature (from X to X)

Conflicts:

	src/compiler/scala/tools/nsc/doc/Settings.scala
	src/compiler/scala/tools/nsc/doc/html/page/Template.scala
	src/compiler/scala/tools/nsc/doc/model/Entity.scala
	src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
	src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala

17 files changed, 529 insertions, 62 deletions

diff --git a/test/scaladoc/resources/implicits-ambiguating-res.scala b/test/scaladoc/resources/implicits-ambiguating-res.scala
new file mode 100644
index 0000000000..6ed51366cb
--- /dev/null
+++ b/test/scaladoc/resources/implicits-ambiguating-res.scala
@@ -0,0 +1,72 @@
+/**
+ *  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 65d7bdf67c..d6c0332c10 100644
--- a/test/scaladoc/resources/implicits-base-res.scala
+++ b/test/scaladoc/resources/implicits-base-res.scala
@@ -16,8 +16,9 @@ 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
- * def convToPimpedA(x: S)                // pimpA4: with 3 constraints: T = Foo[Bar[S]], S: Foo and S: Bar
+ * 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 convToTraversableOps(x: T)         // pimpA7: with 2 constraints: T: Manifest and T <: Double
  *                                        // should not be abstract!
  * }}}
@@ -52,9 +53,10 @@ 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
+ * def convToPimpedA(x: Bar[Foo[Double]]) // pimpA5: no constraints, SHADOWED
+ * def convToPimpedA(x: Double)           // pimpA0: no constraints, SHADOWED
  * def convToTraversableOps(x: Double)    // pimpA7: no constraints
- *                                       // should not be abstract!
+ *                                        // should not be abstract!
  * }}}
  */
 class B extends A[Double]
@@ -68,7 +70,8 @@ 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: Bar[Foo[Int]])    // pimpA5: no constraints
+ * def convToPimpedA(x: Int)              // pimpA0: no constraints, SHADOWED
+ * def convToPimpedA(x: Bar[Foo[Int]])    // pimpA5: no constraints, SHADOWED
  * }}}
  */
 class C extends A[Int]
@@ -81,7 +84,8 @@ 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
+ * def convToPimpedA(x: Bar[Foo[String]]) // pimpA5: no constraints, SHADOWED
+ * def convToPimpedA(x: String)           // pimpA0: no constraints, SHADOWED
  * }}}
  */
 class D extends A[String]
diff --git a/test/scaladoc/resources/implicits-elimination-res.scala b/test/scaladoc/resources/implicits-elimination-res.scala
index b23667440c..5f7135c9e8 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/implicits-elimination.check b/test/scaladoc/run/diagrams-base.check
index 619c56180b..619c56180b 100644
--- a/test/scaladoc/run/implicits-elimination.check
+++ b/test/scaladoc/run/diagrams-base.check
diff --git a/test/scaladoc/run/diagrams-base.scala b/test/scaladoc/run/diagrams-base.scala
new file mode 100644
index 0000000000..38bed06502
--- /dev/null
+++ b/test/scaladoc/run/diagrams-base.scala
@@ -0,0 +1,73 @@
+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
new file mode 100644
index 0000000000..619c56180b
--- /dev/null
+++ b/test/scaladoc/run/diagrams-determinism.check
@@ -0,0 +1 @@
+Done.
diff --git a/test/scaladoc/run/diagrams-determinism.scala b/test/scaladoc/run/diagrams-determinism.scala
new file mode 100644
index 0000000000..6c8db05d78
--- /dev/null
+++ b/test/scaladoc/run/diagrams-determinism.scala
@@ -0,0 +1,67 @@
+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
new file mode 100644
index 0000000000..619c56180b
--- /dev/null
+++ b/test/scaladoc/run/diagrams-filtering.check
@@ -0,0 +1 @@
+Done.
diff --git a/test/scaladoc/run/diagrams-filtering.scala b/test/scaladoc/run/diagrams-filtering.scala
new file mode 100644
index 0000000000..dfde5cac52
--- /dev/null
+++ b/test/scaladoc/run/diagrams-filtering.scala
@@ -0,0 +1,93 @@
+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
new file mode 100644
index 0000000000..619c56180b
--- /dev/null
+++ b/test/scaladoc/run/implicits-ambiguating.check
@@ -0,0 +1 @@
+Done.
diff --git a/test/scaladoc/run/implicits-ambiguating.scala b/test/scaladoc/run/implicits-ambiguating.scala
new file mode 100644
index 0000000000..1420593b74
--- /dev/null
+++ b/test/scaladoc/run/implicits-ambiguating.scala
@@ -0,0 +1,114 @@
+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._
+
+    def isAmbiguous(mbr: MemberEntity): Boolean =
+      mbr.byConversion.map(_.source.implicitsShadowing.get(mbr).map(_.isAmbiguous).getOrElse(false)).getOrElse(false)
+
+    // 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(isAmbiguous(conv1._member(conv)), cls + " - AtoX." + conv + " is ambiguous")
+        assert(isAmbiguous(conv2._member(conv)), cls + " - AtoZ." + conv + " is ambiguous")
+      }
+      for (conv <- (6 to 7).map("conv" + _)) {
+        assert(!isAmbiguous(conv1._member(conv)), cls + " - AtoX." + conv + " is not ambiguous")
+        assert(!isAmbiguous(conv2._member(conv)), cls + " - AtoZ." + conv + " is not ambiguous")
+      }
+      assert(isAmbiguous(conv1._member("conv8")), cls + " - AtoX.conv8 is ambiguous")
+      assert(isAmbiguous(conv2._member("conv8")), cls + " - AtoZ.conv8 is ambiguous")
+      assert(isAmbiguous(conv1._member("conv9")), cls + " - AtoX.conv9 is ambiguous")
+      assert(isAmbiguous(conv2._member("conv9")), cls + " - AtoZ.conv9 is ambiguous")
+    }
+    check1to9("A")
+    assert(!isAmbiguous(conv1._member("conv10")), "A - AtoX.conv10 is not ambiguous")
+    assert(!isAmbiguous(conv2._member("conv10")), "A - AtoZ.conv10 is not ambiguous")
+    assert(!isAmbiguous(conv1._member("conv11")), "A - AtoX.conv11 is not ambiguous")
+    assert(!isAmbiguous(conv2._member("conv11")), "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(isAmbiguous(conv1._member("conv10")), "B - AtoX.conv10 is ambiguous")
+    assert(isAmbiguous(conv2._member("conv10")), "B - AtoZ.conv10 is ambiguous")
+    assert(!isAmbiguous(conv1._member("conv11")), "B - AtoX.conv11 is not ambiguous")
+    assert(!isAmbiguous(conv2._member("conv11")), "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(!isAmbiguous(conv1._member("conv10")), "C - AtoX.conv10 is not ambiguous")
+    assert(!isAmbiguous(conv2._member("conv10")), "C - AtoZ.conv10 is not ambiguous")
+    assert(!isAmbiguous(conv1._member("conv11")), "C - AtoX.conv11 is not ambiguous")
+    assert(!isAmbiguous(conv2._member("conv11")), "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(!isAmbiguous(conv1._member("conv10")), "D - AtoX.conv10 is not ambiguous")
+    assert(!isAmbiguous(conv2._member("conv10")), "D - AtoZ.conv10 is not ambiguous")
+    assert(isAmbiguous(conv1._member("conv11")), "D - AtoX.conv11 is ambiguous")
+    assert(isAmbiguous(conv2._member("conv11")), "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 06d017ed70..3d57306f5d 100644
--- a/test/scaladoc/run/implicits-base.scala
+++ b/test/scaladoc/run/implicits-base.scala
@@ -14,6 +14,9 @@ object Test extends ScaladocModelTest {
     // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
     import access._
 
+    def isShadowed(mbr: MemberEntity): Boolean =
+      mbr.byConversion.map(_.source.implicitsShadowing.get(mbr).map(_.isShadowed).getOrElse(false)).getOrElse(false)
+
     // SEE THE test/resources/implicits-base-res.scala FOR THE EXPLANATION OF WHAT'S CHECKED HERE:
     val base = root._package("scala")._package("test")._package("scaladoc")._package("implicits")._package("base")
     var conv: ImplicitConversion = null
@@ -22,8 +25,12 @@ object Test extends ScaladocModelTest {
 
     val A = base._class("A")
 
-    // the method pimped on by pimpA0 should be shadowed by the method in class A
-    assert(A._conversions(A.qualifiedName + ".pimpA0").isEmpty)
+    // 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(isShadowed(conv._member("convToPimpedA")))
+    assert(conv._member("convToPimpedA").resultType.name == "T")
 
     // def convToNumericA: T               // pimpA1: with a constraint that there is x: Numeric[T] implicit in scope
     conv = A._conversion(A.qualifiedName + ".pimpA1")
@@ -53,6 +60,7 @@ object Test extends ScaladocModelTest {
     conv = A._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
+    assert(isShadowed(conv._member("convToPimpedA")))
     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
@@ -76,10 +84,16 @@ 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(isShadowed(conv._member("convToPimpedA")))
+    assert(conv._member("convToPimpedA").resultType.name == "Double")
+
     // def convToNumericA: Double          // pimpA1: no constraintsd
     conv = B._conversion(A.qualifiedName + ".pimpA1")
     assert(conv.members.length == 1)
@@ -96,6 +110,7 @@ object Test extends ScaladocModelTest {
     conv = B._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
+    assert(isShadowed(conv._member("convToPimpedA")))
     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
@@ -119,11 +134,17 @@ 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(isShadowed(conv._member("convToPimpedA")))
+    assert(conv._member("convToPimpedA").resultType.name == "Int")
+
     // def convToNumericA: Int             // pimpA1: no constraints
     conv = C._conversion(A.qualifiedName + ".pimpA1")
     assert(conv.members.length == 1)
@@ -140,6 +161,7 @@ object Test extends ScaladocModelTest {
     conv = C._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
+    assert(isShadowed(conv._member("convToPimpedA")))
     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
@@ -153,12 +175,18 @@ 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(isShadowed(conv._member("convToPimpedA")))
+    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)
@@ -169,6 +197,7 @@ object Test extends ScaladocModelTest {
     conv = D._conversion(A.qualifiedName + ".pimpA5")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)
+    assert(isShadowed(conv._member("convToPimpedA")))
     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/implicits-elimination.scala b/test/scaladoc/run/implicits-elimination.scala
deleted file mode 100644
index ed37b9cd90..0000000000
--- a/test/scaladoc/run/implicits-elimination.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-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 7835223d21..2827d31122 100644
--- a/test/scaladoc/run/implicits-shadowing.scala
+++ b/test/scaladoc/run/implicits-shadowing.scala
@@ -13,6 +13,9 @@ object Test extends ScaladocModelTest {
     // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s))
     import access._
 
+    def isShadowed(mbr: MemberEntity): Boolean =
+      mbr.byConversion.map(_.source.implicitsShadowing.get(mbr).map(_.isShadowed).getOrElse(false)).getOrElse(false)
+
     // 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("shadowing")
     var conv: ImplicitConversion = null
@@ -22,12 +25,8 @@ object Test extends ScaladocModelTest {
     val A = base._class("A")
 
     conv = A._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 5)
-    conv._member("conv5")
-    conv._member("conv8")
-    conv._member("conv9")
-    conv._member("conv10")
-    conv._member("conv11")
+    assert(conv.members.length == 11)
+    assert(conv.members.forall(isShadowed(_)))
     assert(conv.constraints.length == 0)
 
 //// class B ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -35,11 +34,8 @@ object Test extends ScaladocModelTest {
     val B = base._class("B")
 
     conv = B._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 4)
-    conv._member("conv5")
-    conv._member("conv8")
-    conv._member("conv9")
-    conv._member("conv11")
+    assert(conv.members.length == 11)
+    assert(conv.members.forall(isShadowed(_)))
     assert(conv.constraints.length == 0)
 
 //// class C ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -47,12 +43,8 @@ object Test extends ScaladocModelTest {
     val C = base._class("C")
 
     conv = C._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 5)
-    conv._member("conv5")
-    conv._member("conv8")
-    conv._member("conv9")
-    conv._member("conv10")
-    conv._member("conv11")
+    assert(conv.members.length == 11)
+    assert(conv.members.forall(isShadowed(_)))
     assert(conv.constraints.length == 0)
 
 //// class D ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -60,11 +52,8 @@ object Test extends ScaladocModelTest {
     val D = base._class("D")
 
     conv = D._conversion(base._object("A").qualifiedName + ".AtoZ")
-    assert(conv.members.length == 4)
-    conv._member("conv5")
-    conv._member("conv8")
-    conv._member("conv9")
-    conv._member("conv10")
+    assert(conv.members.length == 11)
+    assert(conv.members.forall(isShadowed(_)))
     assert(conv.constraints.length == 0)
   }
-}
\ No newline at end of file
+}
diff --git a/test/scaladoc/run/implicits-var-exp.check b/test/scaladoc/run/implicits-var-exp.check
new file mode 100644
index 0000000000..619c56180b
--- /dev/null
+++ b/test/scaladoc/run/implicits-var-exp.check
@@ -0,0 +1 @@
+Done.
diff --git a/test/scaladoc/run/implicits-var-exp.scala b/test/scaladoc/run/implicits-var-exp.scala
new file mode 100644
index 0000000000..16569fe3c2
--- /dev/null
+++ b/test/scaladoc/run/implicits-var-exp.scala
@@ -0,0 +1,43 @@
+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.variable.expansion {
+          /**
+           * Blah blah blah
+           */
+          class A
+
+          object A {
+            import language.implicitConversions
+            implicit def aToB(a: A) = new B
+          }
+
+          /**
+           * @define coll collection
+           */
+          class B {
+            /**
+             * foo returns a $coll
+             */
+            def foo: Nothing = ???
+          }
+        }
+    """
+
+  // diagrams must be started. In case there's an error with dot, it should not report anything
+  def scaladocSettings = "-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("variable")._package("expansion")
+    val foo = base._class("A")._method("foo")
+
+    assert(foo.comment.get.body.toString.contains("foo returns a collection"), "\"" + foo.comment.get.body.toString + "\".contains(\"foo returns a collection\")")
+  }
+}
\ No newline at end of file
diff --git a/test/scaladoc/scalacheck/CommentFactoryTest.scala b/test/scaladoc/scalacheck/CommentFactoryTest.scala
index 68ca68efdd..b576ba5544 100644
--- a/test/scaladoc/scalacheck/CommentFactoryTest.scala
+++ b/test/scaladoc/scalacheck/CommentFactoryTest.scala
@@ -5,10 +5,12 @@ 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 CommentFactory with doc.model.TreeFactory =>
+  thisFactory: Factory with ModelFactoryImplicitSupport with DiagramFactory with CommentFactory with doc.model.TreeFactory =>
 
   def strip(c: Comment): Option[Inline] = {
     c.body match {
@@ -29,7 +31,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 CommentFactory with doc.model.TreeFactory)
+    (new Factory(g, settings) with ModelFactoryImplicitSupport with DiagramFactory with CommentFactory with doc.model.TreeFactory)
   }
 
   def parse(src: String, dst: Inline) = {