Fixed "Definition Classes" in bug scala#5287

Vlad Ureche · paulp · commit 98108febce14 · 2011-12-16T14:18:03.000-08:00
diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala
@@ -99,7 +99,7 @@ trait DocComments { self: Global =>
    */
   def useCases(sym: Symbol, site: Symbol): List[(Symbol, String, Position)] = {
     def getUseCases(dc: DocComment) = {
-      for (uc <- dc.useCases; defn <- uc.expandedDefs(site)) yield
+      for (uc <- dc.useCases; defn <- uc.expandedDefs(sym, site)) yield
         (defn,
          expandVariables(merge(cookedDocComment(sym), uc.comment.raw, defn), sym, site),
          uc.pos)
@@ -346,7 +346,7 @@ trait DocComments { self: Global =>
     var defined: List[Symbol] = List() // initialized by Typer
     var aliases: List[Symbol] = List() // initialized by Typer
 
-    def expandedDefs(site: Symbol): List[Symbol] = {
+    def expandedDefs(sym: Symbol, site: Symbol): List[Symbol] = {
 
       def select(site: Type, name: Name, orElse: => Type): Type = {
         val member = site.nonPrivateMember(name)
@@ -424,8 +424,10 @@ trait DocComments { self: Global =>
       }
 
       for (defn <- defined) yield {
-        defn.cloneSymbol.setFlag(Flags.SYNTHETIC).setInfo(
-          substAliases(defn.info).asSeenFrom(site.thisType, defn.owner))
+        val useCase = defn.cloneSymbol
+        useCase.owner = sym.owner
+        useCase.flags = sym.flags
+        useCase.setFlag(Flags.SYNTHETIC).setInfo(substAliases(defn.info).asSeenFrom(site.thisType, sym.owner))
       }
     }
   }
diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -100,11 +100,15 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
       if (inTpl == null) None else thisFactory.comment(sym, inTpl)
     override def inTemplate = inTpl
     override def toRoot: List[MemberImpl] = this :: inTpl.toRoot
-    def inDefinitionTemplates =
-      if (inTpl == null)
-        makeRootPackage.toList
-      else
-        makeTemplate(sym.owner) :: (sym.allOverriddenSymbols map { inhSym => makeTemplate(inhSym.owner) })
+    def inDefinitionTemplates = this match {
+        case mb: NonTemplateMemberEntity if (mb.useCaseOf.isDefined) =>
+          mb.useCaseOf.get.inDefinitionTemplates
+        case _ =>
+          if (inTpl == null) 
+            makeRootPackage.toList
+          else
+            makeTemplate(sym.owner) :: (sym.allOverriddenSymbols map { inhSym => makeTemplate(inhSym.owner) })
+      }
     def visibility = {
       if (sym.isPrivateLocal) PrivateInInstance()
       else if (sym.isProtectedLocal) ProtectedInInstance()
@@ -119,18 +123,14 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
         else Public()
       }
     }
-    def flags = this match { 
-      	// workaround for uninitialized flags in use cases - see SI-5054
-    		case m: NonTemplateMemberEntity if (m.useCaseOf.isDefined) =>
-    			m.useCaseOf.get.flags
-    		case _ =>
-		      val fgs = mutable.ListBuffer.empty[Paragraph]
-		      if (sym.isImplicit) fgs += Paragraph(Text("implicit"))
-		      if (sym.isSealed) fgs += Paragraph(Text("sealed"))
-		      if (!sym.isTrait && (sym hasFlag Flags.ABSTRACT)) fgs += Paragraph(Text("abstract"))
-		      if (!sym.isTrait && (sym hasFlag Flags.DEFERRED)) fgs += Paragraph(Text("abstract"))
-		      if (!sym.isModule && (sym hasFlag Flags.FINAL)) fgs += Paragraph(Text("final"))
-		      fgs.toList    	
+    def flags = { 
+      val fgs = mutable.ListBuffer.empty[Paragraph]
+      if (sym.isImplicit) fgs += Paragraph(Text("implicit"))
+      if (sym.isSealed) fgs += Paragraph(Text("sealed"))
+      if (!sym.isTrait && (sym hasFlag Flags.ABSTRACT)) fgs += Paragraph(Text("abstract"))
+      if (!sym.isTrait && (sym hasFlag Flags.DEFERRED)) fgs += Paragraph(Text("abstract"))
+      if (!sym.isModule && (sym hasFlag Flags.FINAL)) fgs += Paragraph(Text("final"))
+      fgs.toList    	
     }
     def deprecation =
       if (sym.isDeprecated)
diff --git a/src/partest/scala/tools/partest/nest/CompileManager.scala b/src/partest/scala/tools/partest/nest/CompileManager.scala
@@ -75,7 +75,8 @@ class DirectCompiler(val fileManager: FileManager) extends SimpleCompiler {
     val logWriter = new FileWriter(log)
 
     // check whether there is a ".flags" file
-    val flagsFileName = "%s.flags" format (basename(log.getName) dropRight 4) // 4 is "-run" or similar
+    val logFile = basename(log.getName)
+    val flagsFileName = "%s.flags" format (logFile.substring(0, logFile.lastIndexOf("-")))
     val argString = (io.File(log).parent / flagsFileName) ifFile (x => updatePluginPath(x.slurp())) getOrElse ""
     val allOpts = fileManager.SCALAC_OPTS.toList ::: argString.split(' ').toList.filter(_.length > 0)
     val args = allOpts.toList
diff --git a/test/scaladoc/resources/SI_5054_q7.scala b/test/scaladoc/resources/SI_5054_q7.scala
@@ -6,17 +6,17 @@ trait SI_5054_q7 {
    *
    * @param lost a lost parameter
    * @return some integer
-   * @usecase def test(): Int
+   * @usecase def test1(): Int
    *
    * This takes the implicit value in scope.
    *
-   * Example: `test()`
+   * Example: `test1()`
    * 
-   * @usecase def test(explicit: Int): Int
+   * @usecase def test2(explicit: Int): Int
    * 
    * This takes the explicit value passed.
    *
-   * Example: `test(3)`
+   * Example: `test2(3)`
    */
   def test(implicit lost: Int): Int
 }
diff --git a/test/scaladoc/resources/SI_5287.scala b/test/scaladoc/resources/SI_5287.scala
@@ -0,0 +1,17 @@
+trait SI_5287_A {
+	def method(implicit a: Int): Int = a
+}
+
+trait SI_5287_B extends SI_5287_A {
+	override def method(implicit a: Int): Int = a + 1
+}
+
+trait SI_5287 extends SI_5287_B{
+	/**
+	 * Some explanation
+	 * 
+	 * @usecase def method(): Int
+	 * The usecase explanation 
+	 */
+	override def method(implicit a: Int): Int = a + 3
+}
diff --git a/test/scaladoc/scala/html.flags b/test/scaladoc/scala/html.flags
@@ -0,0 +1 @@
+-encoding UTF-8
diff --git a/test/scaladoc/scala/html/HtmlFactoryTest.flags b/test/scaladoc/scala/html/HtmlFactoryTest.flags
@@ -0,0 +1 @@
+-encoding UTF-8
diff --git a/test/scaladoc/scala/html/HtmlFactoryTest.scala b/test/scaladoc/scala/html/HtmlFactoryTest.scala
@@ -21,6 +21,9 @@ object XMLUtil {
 }
 
 object Test extends Properties("HtmlFactory") {
+	
+	final val RESOURCES = "test/scaladoc/resources/"
+	
   import scala.tools.nsc.doc.{DocFactory, Settings}
   import scala.tools.nsc.doc.model.IndexModelFactory
   import scala.tools.nsc.doc.html.HtmlFactory
@@ -47,7 +50,7 @@ object Test extends Properties("HtmlFactory") {
   def createTemplates(basename: String) = {
     val result = scala.collection.mutable.Map[String, scala.xml.NodeSeq]()
 
-    createFactory.makeUniverse(List("test/scaladoc/resources/"+basename)) match {
+    createFactory.makeUniverse(List(RESOURCES+basename)) match {
       case Some(universe) => {
         val index = IndexModelFactory.makeIndex(universe)
         (new HtmlFactory(universe, index)).writeTemplates((page) => {
@@ -61,7 +64,7 @@ object Test extends Properties("HtmlFactory") {
   }
 
   def createReferenceIndex(basename: String) = {
-    createFactory.makeUniverse(List("test/scaladoc/resources/"+basename)) match {
+    createFactory.makeUniverse(List(RESOURCES+basename)) match {
       case Some(universe) => {
         val index = IndexModelFactory.makeIndex(universe)
         val pages = index.firstLetterIndex.map({
@@ -81,6 +84,52 @@ object Test extends Properties("HtmlFactory") {
     val html = scala.stripSuffix(".scala") + ".html"
     createTemplates(scala)(html)
   }
+  
+  /**
+   * See checkTextOnly(scalaFile: String, checks: List[String])
+   */
+  def checkText1(scalaFile: String, check: String, debug: Boolean = true): Boolean = checkText(scalaFile, List(check), debug)
+  
+  /**
+   * This tests the text without the markup - ex:
+   * 
+   * <h4 class="signature">
+   *  <span class="modifier_kind">
+   *    <span class="modifier">implicit</span>
+   *    <span class="kind">def</span>
+   *  </span>
+   *  <span class="symbol">
+   *    <span class="name">test</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
+   *  </span>
+   *  </h4>
+   * 
+   * becomes:
+   * 
+   *  implicit def test(): Int
+   *  
+   * and is required to contain the text in the given checks
+   * 
+   * NOTE: Comparison is done ignoring all whitespace
+   */
+  def checkText(scalaFile: String, checks: List[String], debug: Boolean = true): Boolean = {
+    val htmlFile = scalaFile.stripSuffix(".scala") + ".html"    
+    val htmlText = createTemplates(scalaFile)(htmlFile).text.replace('→',' ').replaceAll("\\s+","")
+    var result = true
+    
+    for (check <- checks) {
+    	val checkText = check.replace('→',' ').replaceAll("\\s+","")
+    	val checkValue = htmlText.contains(checkText)
+    	if (debug && (!checkValue)) {
+    		Console.err.println("Check failed: ")
+    		Console.err.println("HTML: " + htmlText)
+    		Console.err.println("Check: " + checkText)
+    	}
+  		result &&= checkValue 
+    }
+    
+    result
+  }
+  
 
   def shortComments(root: scala.xml.Node) =
     XMLUtil.stripGroup(root).descendant.flatMap {
@@ -377,113 +426,43 @@ object Test extends Properties("HtmlFactory") {
     createTemplate("SI_4898.scala")
     true
   }
-
-  // A piece of the signature - corresponding to the use case
-  def signature(no: Int, modifier: String) = ("""
-    <li visbl="pub" name="SI_5054_q""" + no + """#test" data-isabs="false">
-      <a id="test():Int"></a>
-      <h4 class="signature">
-      <span class="modifier_kind">
-        <span class="modifier">""" + modifier + """</span>
-        <span class="kind">def</span>
-      </span>
-      <span class="symbol">
-        <span class="name">test</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
-      </span>
-      </h4>
-      <p class="shortcomment cmt">[use case]
-      </p>
-    </li>""").replaceAll("\\s+", "")
   
-  property("Use cases should override their original members") = {
-    createTemplate("SI_5054_q1.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(signature(1, ""))
-      case _ => false
-    }
-  }
-
-  property("Use cases should keep their flags - final should not be lost") = {
-    createTemplate("SI_5054_q2.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(signature(2, "final"))
-      case _ => false
-    }
-  }
+  property("Use cases should override their original members") =
+     checkText1("SI_5054_q1.scala", """def test(): Int""") &&
+     !checkText1("SI_5054_q1.scala", """def test(implicit lost: Int): Int""")
   
-  property("Use cases should keep their flags - implicit should not be lost") = {
-    createTemplate("SI_5054_q3.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(signature(3, "implicit"))
-      case _ => false
-    }
-  }
 
-  property("Use cases should keep their flags - real abstract should not be lost") = {
-    createTemplate("SI_5054_q4.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(signature(4, "abstract"))
-      case _ => false
-    }
-  }
-
-  property("Use cases should keep their flags - traits should not be affected") = {
-    createTemplate("SI_5054_q5.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(signature(5, ""))
-      case _ => false
-    }
-  }
-
-  property("Use cases should keep their flags - traits should not be affected") = {
-    createTemplate("SI_5054_q6.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(signature(6, "abstract"))
-      case _ => false
-    }
-  }
+  property("Use cases should keep their flags - final should not be lost") = 
+    checkText1("SI_5054_q2.scala", """final def test(): Int""")
   
-  val useCaseExplanation = """
-   </li><li visbl="pub" name="SI_5054_q7#test" data-isabs="false">
-      <a id="test():Int"></a>
-      <h4 class="signature">
-      <span class="modifier_kind">
-        <span class="modifier">abstract </span>
-        <span class="kind">def</span>
-      </span>
-      <span class="symbol">
-        <span class="name">test</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
-      </span>
-      </h4>
-      <p class="shortcomment cmt">[use case] This takes the implicit value in scope.</p><div class="fullcomment">[use case] <div class="comment cmt"><p>This takes the implicit value in scope.</p><p>Example: <code>test()</code></p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>some integer
-   </p></dd></dl></div>
-    </li><li visbl="pub" name="SI_5054_q7#test" data-isabs="false">
-      <a id="test(Int):Int"></a>
-      <h4 class="signature">
-      <span class="modifier_kind">
-        <span class="modifier">abstract </span>
-        <span class="kind">def</span>
-      </span>
-      <span class="symbol">
-        <span class="name">test</span><span class="params">(<span name="explicit">explicit: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
-      </span>
-      </h4>
-      <p class="shortcomment cmt">[use case] This takes the explicit value passed.</p><div class="fullcomment">[use case] <div class="comment cmt"><p>This takes the explicit value passed.</p><p>Example: <code>test(3)</code></p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>some integer
-   </p></dd></dl></div>
-    </li>
-  """.replaceAll("\\s+","")
- 
-  property("Use case individual signature test") = {
-    createTemplate("SI_5054_q7.scala") match {
-      case node: scala.xml.Node =>
-        node.toString.replaceAll("\\s+","").contains(useCaseExplanation)
-      case _ => false
-    }
-  }
+  property("Use cases should keep their flags - implicit should not be lost") = 
+    checkText1("SI_5054_q3.scala", """implicit def test(): Int""")
+
+  property("Use cases should keep their flags - real abstract should not be lost") = 
+    checkText1("SI_5054_q4.scala", """abstract def test(): Int""")
+
+  property("Use cases should keep their flags - traits should not be affected") = 
+    checkText1("SI_5054_q5.scala", """def test(): Int""")
+
+  property("Use cases should keep their flags - traits should not be affected") = 
+    checkText1("SI_5054_q6.scala", """abstract def test(): Int""")
+   
+  property("Use case individual signature test") = 
+    checkText("SI_5054_q7.scala", List( 
+        """abstract def test2(explicit: Int): Int [use case] This takes the explicit value passed.""",
+        """abstract def test1(): Int [use case] This takes the implicit value in scope."""))
+
+  property("Display correct \"Definition classes\"") = 
+    checkText1("SI_5287.scala", 
+        """def method(): Int
+           [use case] The usecase explanation
+           [use case] The usecase explanation
+           Definition Classes SI_5287 SI_5287_B SI_5287_A""", debug=true) 
+           // explanation appears twice, as small comment and full comment
   
   {
     val files = createTemplates("basic.scala")
-    println(files)
+    //println(files)
 
     property("class") = files.get("com/example/p1/Clazz.html") match {
       case Some(node: scala.xml.Node) => {

Original file line number	Diff line number	Diff line change
`@@ -6,17 +6,17 @@ trait SI_5054_q7 {`
`6`	`6`	`*`
`7`	`7`	`* @param lost a lost parameter`
`8`	`8`	`* @return some integer`
`9`		`- * @usecase def test(): Int`
	`9`	`+ * @usecase def test1(): Int`
`10`	`10`	`*`
`11`	`11`	`* This takes the implicit value in scope.`
`12`	`12`	`*`
`13`		- * Example: `test()`
	`13`	+ * Example: `test1()`
`14`	`14`	`*`
`15`		`- * @usecase def test(explicit: Int): Int`
	`15`	`+ * @usecase def test2(explicit: Int): Int`
`16`	`16`	`*`
`17`	`17`	`* This takes the explicit value passed.`
`18`	`18`	`*`
`19`		- * Example: `test(3)`
	`19`	+ * Example: `test2(3)`
`20`	`20`	`*/`
`21`	`21`	`def test(implicit lost: Int): Int`
`22`	`22`	`}`