Scaladoc feature that shows implicit conversions

See https://github.com/VladUreche/scala/tree/feature/doc-implicits for the history.
See https://scala-webapps.epfl.ch/jenkins/view/scaladoc/job/scaladoc-implicits-nightly/ for nightlies.

Many thanks fly out to Adriaan for his help with implicit search!

1 files changed, 50 insertions, 28 deletions

diff --git a/src/partest/scala/tools/partest/ScaladocModelTest.scala b/src/partest/scala/tools/partest/ScaladocModelTest.scala
index 2eb026ceee..142f2baea5 100644
--- a/src/partest/scala/tools/partest/ScaladocModelTest.scala
+++ b/src/partest/scala/tools/partest/ScaladocModelTest.scala
@@ -21,10 +21,10 @@ import scala.tools.nsc.reporters.ConsoleReporter
       import scala.tools.nsc.doc.model._
       import scala.tools.partest.ScaladocModelTest
 
-      object Test extends ScaladocModelTest {  
+      object Test extends ScaladocModelTest {
 
-        def code = """ ... """
-        def scaladocSettings = ""
+        override def code = """ ... """ // or override def resourceFile = "<file>.scala" (from test/scaladoc/resources)
+        def scaladocSettings = " ... "
         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._
@@ -39,10 +39,22 @@ abstract class ScaladocModelTest extends DirectTest {
 
   /** Override this to give scaladoc command line parameters */
   def scaladocSettings: String
-  
+
   /** Override this to test the model */
   def testModel(root: Package): Unit
 
+  /** Override to feed a file in resources to scaladoc*/
+  def resourceFile: String = null
+
+  /** Override to feed code into scaladoc */
+  override def code =
+    if (resourceFile ne null)
+      io.File(resourcePath + "/" + resourceFile).slurp()
+    else
+      sys.error("Scaladoc Model Test: You need to give a file or some code to feed to scaladoc!")
+
+  def resourcePath = io.Directory(sys.props("partest.cwd") + "/../resources")
+
   // Implementation follows:
   override def extraSettings: String = "-usejavacp"
 
@@ -50,15 +62,15 @@ abstract class ScaladocModelTest extends DirectTest {
     // redirect err to out, for logging
     val prevErr = System.err
     System.setErr(System.out)
-    
+
     try {
       // 1 - compile with scaladoc and get the model out
-      val args = scaladocSettings.split(" ")
-      val universe = model(args:_*).getOrElse({sys.error("Scaladoc Model Test ERROR: No universe generated!")})
+      val universe = model.getOrElse({sys.error("Scaladoc Model Test ERROR: No universe generated!")})
       // 2 - check the model generated
       testModel(universe.rootPackage)
+      println("Done.")
     } catch {
-      case e => 
+      case e =>
         println(e)
         e.printStackTrace
     }
@@ -66,51 +78,46 @@ abstract class ScaladocModelTest extends DirectTest {
     System.setErr(prevErr)
   }
 
+  private[this] var settings: Settings = null
+
   // create a new scaladoc compiler
-  def newDocFactory(args: String*): DocFactory = {
-    val settings = new Settings(_ => ())
-    val command = new ScalaDoc.Command((CommandLineParser tokenize extraSettings) ++ args.toList, settings)
+  def newDocFactory: DocFactory = {
+    settings = new Settings(_ => ())
+    settings.reportModel = false // yaay, no more "model contains X documentable templates"!
+    val args = extraSettings + " " + scaladocSettings
+    val command = new ScalaDoc.Command((CommandLineParser tokenize (args)), settings)
     val docFact = new DocFactory(new ConsoleReporter(settings), settings)
     docFact
   }
 
   // compile with scaladoc and output the result
-  def model(args: String*): Option[Universe] = newDocFactory(args: _*).makeUniverse(Right(code))
+  def model: Option[Universe] = newDocFactory.makeUniverse(Right(code))
 
   // so we don't get the newSettings warning
-  override def isDebug = false 
+  override def isDebug = false
 
 
   // finally, enable easy navigation inside the entities
   object access {
 
-    // Make it easy to access things
     class TemplateAccess(tpl: DocTemplateEntity) {
-
       def _class(name: String): DocTemplateEntity = getTheFirst(_classes(name), tpl.qualifiedName + ".class(" + name + ")")
-      def _classes(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).flatMap({ case c: Class => List(c)})
+      def _classes(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).collect({ case c: Class => c})
 
       def _trait(name: String): DocTemplateEntity = getTheFirst(_traits(name), tpl.qualifiedName + ".trait(" + name + ")")
-      def _traits(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).flatMap({ case t: Trait => List(t)})
+      def _traits(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).collect({ case t: Trait => t})
 
       def _object(name: String): DocTemplateEntity = getTheFirst(_objects(name), tpl.qualifiedName + ".object(" + name + ")")
-      def _objects(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).flatMap({ case o: Object => List(o)})
+      def _objects(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).collect({ case o: Object => o})
 
       def _method(name: String): Def = getTheFirst(_methods(name), tpl.qualifiedName + ".method(" + name + ")")
       def _methods(name: String): List[Def] = tpl.methods.filter(_.name == name)
-      
+
       def _value(name: String): Val = getTheFirst(_values(name), tpl.qualifiedName + ".value(" + name + ")")
       def _values(name: String): List[Val] = tpl.values.filter(_.name == name)
 
-      def getTheFirst[T](list: List[T], expl: String): T = {
-        if (list.length == 1)
-          list.head
-        else if (list.length == 0)
-          sys.error("Error getting " + expl + ": No such element. All elements in list: [" + list.mkString(", ") + "]")
-        else 
-          sys.error("Error getting " + expl + ": " + list.length + " elements with this name. " +
-            "All elements in list: [" + list.mkString(", ") + "]")
-      }
+      def _conversion(name: String): ImplicitConversion = getTheFirst(_conversions(name), tpl.qualifiedName + ".conversion(" + name + ")")
+      def _conversions(name: String): List[ImplicitConversion] = tpl.conversions.filter(_.conversionQualifiedName == name)
     }
 
     class PackageAccess(pack: Package) extends TemplateAccess(pack) {
@@ -118,7 +125,22 @@ abstract class ScaladocModelTest extends DirectTest {
       def _packages(name: String): List[Package] = pack.packages.filter(_.name == name)
     }
 
+    class MemberAccess(mbrs: WithMembers) {
+      def _member(name: String): MemberEntity = getTheFirst(_members(name), mbrs.toString + ".member(" + name + ")")
+      def _members(name: String): List[MemberEntity] = mbrs.members.filter(_.name == name)
+    }
+
+    type WithMembers = { def members: List[MemberEntity]; def toString: String } /* DocTemplates and ImplicitConversions */
+
     implicit def templateAccess(tpl: DocTemplateEntity) = new TemplateAccess(tpl)
     implicit def packageAccess(pack: Package) = new PackageAccess(pack)
+    implicit def membersAccess(mbrs: WithMembers) = new MemberAccess(mbrs)
+
+    def getTheFirst[T](list: List[T], expl: String): T = list.length match {
+      case 1 => list.head
+      case 0 => sys.error("Error getting " + expl + ": No such element.")
+      case _ => sys.error("Error getting " + expl + ": " + list.length + " elements with this name. " +
+                  "All elements in list: [" + list.mkString(", ") + "]")
+    }
   }
 }