Diagram tweaks #2

- fixed the AnyRef linking (SI-5780)
- added tooltips to implicit conversions in diagrams
- fixed the intermittent dot error where node images would be left out
(dot is not reliable at all -- with all the mechanisms in place to fail
gracefully, we still get dot errors crawling their way into diagrams -
and that usually means no diagram generated, which is the most
appropriate way to fail, I think...)

Author: VladUreche

src/compiler/scala/tools/nsc/doc/html/page/diagram/DiagramStats.scala

@@ -38,6 +38,8 @@ object DiagramStats {
   private[this] val dotGenTrack = new TimeTracker("dot diagram generation")
   private[this] val dotRunTrack = new TimeTracker("dot process runnning")
   private[this] val svgTrack = new TimeTracker("svg processing")
+  private[this] var brokenImages = 0
+  private[this] var fixedImages = 0
 
   def printStats(settings: Settings) = {
     if (settings.docDiagramsDebug.value) {
@@ -47,6 +49,9 @@ object DiagramStats {
       dotGenTrack.printStats(settings.printMsg)
       dotRunTrack.printStats(settings.printMsg)
       svgTrack.printStats(settings.printMsg)
+      println("  Broken images: " + brokenImages)
+      println("  Fixed images: " + fixedImages)
+      println("")
     }
   }
 
@@ -55,4 +60,7 @@ object DiagramStats {
   def addDotGenerationTime(ms: Long) = dotGenTrack.addTime(ms)
   def addDotRunningTime(ms: Long) = dotRunTrack.addTime(ms)
   def addSvgTime(ms: Long) = svgTrack.addTime(ms)
+
+  def addBrokenImage(): Unit = brokenImages += 1
+  def addFixedImage(): Unit = fixedImages += 1
 }

src/compiler/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala

@@ -66,10 +66,6 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
     var superClasses = List[Node]()
     var incomingImplicits = List[Node]()
     var outgoingImplicits = List[Node]()
-    var subClassesTooltip: Option[String] = None
-    var superClassesTooltip: Option[String] = None
-    var incomingImplicitsTooltip: Option[String] = None
-    var outgoingImplicitsTooltip: Option[String] = None
     isClassDiagram = false
 
     d match {
@@ -89,23 +85,23 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
         //   if there are too many super / sub / implicit nodes, represent
         //   them by on node with a corresponding tooltip
         superClasses = if (_superClasses.length > settings.docDiagramsMaxNormalClasses.value) {
-          superClassesTooltip = Some(limitSize(_superClasses.map(_.tpe.name).mkString(", ")))
-          List(NormalNode(textTypeEntity(_superClasses.length + MultiSuffix), None))
+          val superClassesTooltip = Some(limitSize(_superClasses.map(_.tpe.name).mkString(", ")))
+          List(NormalNode(textTypeEntity(_superClasses.length + MultiSuffix), None, superClassesTooltip))
         } else _superClasses
 
         subClasses = if (_subClasses.length > settings.docDiagramsMaxNormalClasses.value) {
-          subClassesTooltip = Some(limitSize(_subClasses.map(_.tpe.name).mkString(", ")))
-          List(NormalNode(textTypeEntity(_subClasses.length + MultiSuffix), None))
+          val subClassesTooltip = Some(limitSize(_subClasses.map(_.tpe.name).mkString(", ")))
+          List(NormalNode(textTypeEntity(_subClasses.length + MultiSuffix), None, subClassesTooltip))
         } else _subClasses
 
         incomingImplicits = if (_incomingImplicits.length > settings.docDiagramsMaxImplicitClasses.value) {
-          incomingImplicitsTooltip = Some(limitSize(_incomingImplicits.map(_.tpe.name).mkString(", ")))
-          List(ImplicitNode(textTypeEntity(_incomingImplicits.length + MultiSuffix), None))
+          val incomingImplicitsTooltip = Some(limitSize(_incomingImplicits.map(_.tpe.name).mkString(", ")))
+          List(ImplicitNode(textTypeEntity(_incomingImplicits.length + MultiSuffix), None, incomingImplicitsTooltip))
         } else _incomingImplicits
 
         outgoingImplicits = if (_outgoingImplicits.length > settings.docDiagramsMaxImplicitClasses.value) {
-          outgoingImplicitsTooltip = Some(limitSize(_outgoingImplicits.map(_.tpe.name).mkString(", ")))
-          List(ImplicitNode(textTypeEntity(_outgoingImplicits.length + MultiSuffix), None))
+          val outgoingImplicitsTooltip = Some(limitSize(_outgoingImplicits.map(_.tpe.name).mkString(", ")))
+          List(ImplicitNode(textTypeEntity(_outgoingImplicits.length + MultiSuffix), None, outgoingImplicitsTooltip))
         } else _outgoingImplicits
 
         thisNode = _thisNode
@@ -128,14 +124,14 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
         // dot cluster containing thisNode
         val thisCluster = "subgraph clusterThis {\n" +
           "style=\"invis\"\n" +
-          node2Dot(thisNode, None) +
+          node2Dot(thisNode) +
         "}"
         // dot cluster containing incoming implicit nodes, if any
         val incomingCluster = {
           if(incomingImplicits.isEmpty) ""
           else "subgraph clusterIncoming {\n" +
             "style=\"invis\"\n" +
-            incomingImplicits.reverse.map(n => node2Dot(n, incomingImplicitsTooltip)).mkString +
+            incomingImplicits.reverse.map(n => node2Dot(n)).mkString +
             (if (incomingImplicits.size > 1)
               incomingImplicits.map(n => "node" + node2Index(n)).mkString(" -> ") +
               " [constraint=\"false\", style=\"invis\", minlen=\"0.0\"];\n"
@@ -147,7 +143,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
           if(outgoingImplicits.isEmpty) ""
           else "subgraph clusterOutgoing {\n" +
             "style=\"invis\"\n" +
-            outgoingImplicits.reverse.map(n => node2Dot(n, outgoingImplicitsTooltip)).mkString +
+            outgoingImplicits.reverse.map(n => node2Dot(n)).mkString +
             (if (outgoingImplicits.size > 1)
               outgoingImplicits.map(n => "node" + node2Index(n)).mkString(" -> ") +
               " [constraint=\"false\", style=\"invis\", minlen=\"0.0\"];\n"
@@ -189,9 +185,9 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
       "edge [" + edgeAttributesStr + "];\n" +
       implicitsDot + "\n" +
       // inheritance nodes
-      nodes.map(n => node2Dot(n, None)).mkString +
-      subClasses.map(n => node2Dot(n, subClassesTooltip)).mkString +
-      superClasses.map(n => node2Dot(n, superClassesTooltip)).mkString +
+      nodes.map(n => node2Dot(n)).mkString +
+      subClasses.map(n => node2Dot(n)).mkString +
+      superClasses.map(n => node2Dot(n)).mkString +
       // inheritance edges
       edges.map{ case (from, tos) => tos.map(to => {
         val id = "graph" + counter + "_" + node2Index(to) + "_" + node2Index(from)
@@ -213,7 +209,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
   /**
    * Generates the dot string of a given node.
    */
-  private def node2Dot(node: Node, tooltip: Option[String]) = {
+  private def node2Dot(node: Node) = {
 
     // escape HTML characters in node names
     def escape(name: String) = name.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
@@ -228,7 +224,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
     }
 
     // tooltip
-    tooltip match {
+    node.tooltip match {
       case Some(text) => attr += "tooltip" -> text
       // show full name where available (instead of TraversableOps[A] show scala.collection.parallel.TraversableOps[A])
       case None if node.tpl.isDefined => attr += "tooltip" -> node.tpl.get.qualifiedName
@@ -294,25 +290,23 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
    */
   private def cssClass(node: Node): String =
     if (node.isImplicitNode && incomingImplicitNodes.contains(node))
-      "implicit-incoming"
+      "implicit-incoming" + cssBaseClass(node, "", " ")
     else if (node.isImplicitNode)
-      "implicit-outgoing"
-    else if (node.isObjectNode)
-      "object"
+      "implicit-outgoing" + cssBaseClass(node, "", " ")
     else if (node.isThisNode)
-      "this" + cssBaseClass(node, "")
+      "this" + cssBaseClass(node, "", " ")
     else if (node.isOutsideNode)
-      "outside" + cssBaseClass(node, "")
+      "outside" + cssBaseClass(node, "", " ")
     else
-      cssBaseClass(node, "default")
+      cssBaseClass(node, "default", "")
 
-  private def cssBaseClass(node: Node, default: String) =
+  private def cssBaseClass(node: Node, default: String, space: String) =
     if (node.isClassNode)
-      " class"
+      space + "class"
     else if (node.isTraitNode)
-      " trait"
+      space + "trait"
     else if (node.isObjectNode)
-      " trait"
+      space + "object"
     else
       default
 
@@ -381,10 +375,31 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
     // assign id and class attributes to edges and nodes:
     // the id attribute generated by dot has the format: "{class}|{id}"
     case g @ Elem(prefix, "g", attribs, scope, children @ _*) if (List("edge", "node").contains((g \ "@class").toString)) => {
-      val res = new Elem(prefix, "g", attribs, scope, (children map(x => transform(x))): _*)
+      var res = new Elem(prefix, "g", attribs, scope, (children map(x => transform(x))): _*)
       val dotId = (g \ "@id").toString
       if (dotId.count(_ == '|') == 1) {
         val Array(klass, id) = dotId.toString.split("\\|")
+        /* Sometimes dot "forgets" to add the image -- that's very annoying, but it seems pretty random, and simple
+         * tests like excute 20K times and diff the output don't trigger the bug -- so it's up to us to place the image
+         * back in the node */
+        val kind = getKind(klass)
+        if (kind != "")
+          if (((g \ "a" \ "image").isEmpty)) {
+            DiagramStats.addBrokenImage()
+            val xposition = getPosition(g, "x", -22)
+            val yposition = getPosition(g, "y", -11.3334)
+            if (xposition.isDefined && yposition.isDefined) {
+              val imageNode = <image xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href={ ("./lib/" + kind + "_diagram.png") } width="16px" height="16px" preserveAspectRatio="xMinYMin meet" x={ xposition.get.toString } y={ yposition.get.toString }/>
+              val anchorNode = (g \ "a") match {
+                case Seq(Elem(prefix, "a", attribs, scope, children @ _*)) =>
+                  transform(new Elem(prefix, "a", attribs, scope, (children ++ imageNode): _*))
+                case _ =>
+                  g \ "a"
+              }
+              res = new Elem(prefix, "g", attribs, scope, anchorNode: _*)
+              DiagramStats.addFixedImage()
+            }
+          }
         res % new UnprefixedAttribute("id", id, Null) %
         new UnprefixedAttribute("class", (g \ "@class").toString + " " + klass, Null)
       }
@@ -399,6 +414,20 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
     case x => x
   }
 
+  def getKind(klass: String): String =
+    if (klass.contains("class")) "class"
+    else if (klass.contains("trait")) "trait"
+    else if (klass.contains("object")) "object"
+    else ""
+
+  def getPosition(g: xml.Node, axis: String, offset: Double): Option[Double] = {
+    val node = g \ "a" \ "text" \ ("@" + axis)
+    if (node.isEmpty)
+      None
+    else
+      Some(node.toString.toDouble + offset)
+  }
+
   /* graph / node / edge attributes */
 
   private val graphAttributes: Map[String, String] = Map(

src/compiler/scala/tools/nsc/doc/model/Entity.scala

@@ -278,11 +278,11 @@ trait DocTemplateEntity extends TemplateEntity with MemberEntity {
   def implicitsShadowing: Map[MemberEntity, ImplicitMemberShadowing]
 
   /** Classes that can be implcitly converted to this class */
-  def incomingImplicitlyConvertedClasses: List[DocTemplateEntity]
+  def incomingImplicitlyConvertedClasses: List[(DocTemplateEntity, ImplicitConversion)]
 
   /** Classes to which this class can be implicitly converted to
       NOTE: Some classes might not be included in the scaladoc run so they will be NoDocTemplateEntities */
-  def outgoingImplicitlyConvertedClasses: List[(TemplateEntity, TypeEntity)]
+  def outgoingImplicitlyConvertedClasses: List[(TemplateEntity, TypeEntity, ImplicitConversion)]
 
   /** If this template takes place in inheritance and implicit conversion relations, it will be shown in this diagram */
   def inheritanceDiagram: Option[Diagram]

src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala

@@ -299,14 +299,14 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     def directSubClasses = allSubClasses.filter(_.parentTypes.map(_._1).contains(this))
 
     /* Implcitly convertible class cache */
-    private var implicitlyConvertibleClassesCache: mutable.ListBuffer[DocTemplateEntity] = null
-    def registerImplicitlyConvertibleClass(sc: DocTemplateEntity): Unit = {
+    private var implicitlyConvertibleClassesCache: mutable.ListBuffer[(DocTemplateEntity, ImplicitConversionImpl)] = null
+    def registerImplicitlyConvertibleClass(dtpl: DocTemplateEntity, conv: ImplicitConversionImpl): Unit = {
       if (implicitlyConvertibleClassesCache == null)
-        implicitlyConvertibleClassesCache = mutable.ListBuffer[DocTemplateEntity]()
-      implicitlyConvertibleClassesCache += sc
+        implicitlyConvertibleClassesCache = mutable.ListBuffer[(DocTemplateEntity, ImplicitConversionImpl)]()
+      implicitlyConvertibleClassesCache += ((dtpl, conv))
     }
 
-    def incomingImplicitlyConvertedClasses: List[DocTemplateEntity] =
+    def incomingImplicitlyConvertedClasses: List[(DocTemplateEntity, ImplicitConversionImpl)] =
       if (implicitlyConvertibleClassesCache == null)
         List()
       else
@@ -363,18 +363,19 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
 
     var implicitsShadowing = Map[MemberEntity, ImplicitMemberShadowing]()
 
-    lazy val outgoingImplicitlyConvertedClasses: List[(TemplateEntity, TypeEntity)] = conversions flatMap (conv =>
-      if (!implicitExcluded(conv.conversionQualifiedName))
-        conv.targetTypeComponents map {
-          case pair@(template, tpe) =>
-            template match {
-              case d: DocTemplateImpl => d.registerImplicitlyConvertibleClass(this)
-              case _ => // nothing
-            }
-            pair
-        }
-      else List()
-    )
+    lazy val outgoingImplicitlyConvertedClasses: List[(TemplateEntity, TypeEntity, ImplicitConversionImpl)] =
+      conversions flatMap (conv =>
+        if (!implicitExcluded(conv.conversionQualifiedName))
+          conv.targetTypeComponents map {
+            case pair@(template, tpe) =>
+              template match {
+                case d: DocTemplateImpl => d.registerImplicitlyConvertibleClass(this, conv)
+                case _ => // nothing
+              }
+              (pair._1, pair._2, conv)
+          }
+        else List()
+      )
 
     override def isTemplate = true
     lazy val definitionName = optimize(inDefinitionTemplates.head.qualifiedName + "." + name)
@@ -862,7 +863,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
           //   nameBuffer append stripPrefixes.foldLeft(pre.prefixString)(_ stripPrefix _)
           // }
           val bSym = normalizeTemplate(aSym)
-          if (bSym.isNonClassType) {
+          if (bSym.isNonClassType && bSym != AnyRefClass) {
             nameBuffer append bSym.decodedName
           } else {
             val tpl = makeTemplate(bSym)

src/compiler/scala/tools/nsc/doc/model/diagram/Diagram.scala

@@ -73,6 +73,7 @@ abstract class Node {
   def isOtherNode = !(isClassNode || isTraitNode || isObjectNode)
   def isImplicitNode = false
   def isOutsideNode = false
+  def tooltip: Option[String]
 }
 
 // different matchers, allowing you to use the pattern matcher against any node
@@ -97,20 +98,20 @@ object OtherNode   { def unapply(n: Node): Option[(TypeEntity, Option[TemplateEn
 
 
 /** The node for the current class */
-case class ThisNode(tpe: TypeEntity, tpl: Option[TemplateEntity]) extends Node { override def isThisNode = true }
+case class ThisNode(tpe: TypeEntity, tpl: Option[TemplateEntity], tooltip: Option[String] = None) extends Node { override def isThisNode = true }
 
 /** The usual node */
-case class NormalNode(tpe: TypeEntity, tpl: Option[TemplateEntity]) extends Node { override def isNormalNode = true }
+case class NormalNode(tpe: TypeEntity, tpl: Option[TemplateEntity], tooltip: Option[String] = None) extends Node { override def isNormalNode = true }
 
 /** A class or trait the thisnode can be converted to by an implicit conversion
  *  TODO: I think it makes more sense to use the tpe links to templates instead of the TemplateEntity for implicit nodes
  *  since some implicit conversions convert the class to complex types that cannot be represented as a single tmeplate
  */
-case class ImplicitNode(tpe: TypeEntity, tpl: Option[TemplateEntity]) extends Node { override def isImplicitNode = true }
+case class ImplicitNode(tpe: TypeEntity, tpl: Option[TemplateEntity], tooltip: Option[String] = None) extends Node { override def isImplicitNode = true }
 
 /** An outside node is shown in packages when a class from a different package makes it to the package diagram due to
  * its relation to a class in the template (see @contentDiagram hideInheritedNodes annotation) */
-case class OutsideNode(tpe: TypeEntity, tpl: Option[TemplateEntity]) extends Node { override def isOutsideNode = true }
+case class OutsideNode(tpe: TypeEntity, tpl: Option[TemplateEntity], tooltip: Option[String] = None) extends Node { override def isOutsideNode = true }
 
 
 // Computing and offering node depth information

src/compiler/scala/tools/nsc/doc/model/diagram/DiagramFactory.scala

@@ -43,12 +43,16 @@ trait DiagramFactory extends DiagramDirectiveParser {
     // the diagram filter
     val diagramFilter = makeInheritanceDiagramFilter(tpl)
 
+    def implicitTooltip(from: DocTemplateEntity, to: TemplateEntity, conv: ImplicitConversion) =
+      Some(from.qualifiedName + " can be implicitly converted to " + conv.targetType + " by the implicit method "
+        + conv.conversionShortName + " in " + conv.convertorOwner.kind + " " + conv.convertorOwner.qualifiedName)
+
     val result =
       if (diagramFilter == NoDiagramAtAll)
         None
       else {
         // the main node
-        val thisNode = ThisNode(tpl.ownType, Some(tpl))
+        val thisNode = ThisNode(tpl.ownType, Some(tpl), Some(tpl.qualifiedName + " (this " + tpl.kind + ")"))
 
         // superclasses
         var superclasses: List[Node] =
@@ -57,7 +61,10 @@ trait DiagramFactory extends DiagramDirectiveParser {
           }.reverse
 
         // incoming implcit conversions
-        lazy val incomingImplicitNodes = tpl.incomingImplicitlyConvertedClasses.map(tpl => ImplicitNode(tpl.ownType, Some(tpl)))
+        lazy val incomingImplicitNodes = tpl.incomingImplicitlyConvertedClasses.map {
+          case (incomingTpl, conv) =>
+            ImplicitNode(incomingTpl.ownType, Some(incomingTpl), implicitTooltip(from=incomingTpl, to=tpl, conv=conv))
+        }
 
         // subclasses
         var subclasses: List[Node] =
@@ -67,7 +74,10 @@ trait DiagramFactory extends DiagramDirectiveParser {
           }.sortBy(_.tpl.get.name)(implicitly[Ordering[String]].reverse)
 
         // outgoing implicit coversions
-        lazy val outgoingImplicitNodes = tpl.outgoingImplicitlyConvertedClasses.map(pair => ImplicitNode(pair._2, Some(pair._1)))
+        lazy val outgoingImplicitNodes = tpl.outgoingImplicitlyConvertedClasses.map {
+          case (outgoingTpl, outgoingType, conv) =>
+            ImplicitNode(outgoingType, Some(outgoingTpl), implicitTooltip(from=tpl, to=tpl, conv=conv))
+        }
 
         // TODO: Everyone should be able to use the @{inherit,content}Diagram annotation to change the diagrams.
         // Currently, it's possible to leave nodes and edges out, but there's no way to create new nodes and edges