SI-5543: Merge with trunk

Reverts name unenmanglement that was objectionable in the previous patch
commit 47bfd744177121de08fed489a5b0b1b59a1ae06a.

7 files changed, 186 insertions, 23 deletions

diff --git a/src/partest/scala/tools/partest/CompilerTest.scala b/src/partest/scala/tools/partest/CompilerTest.scala
index 994928c0f6..86678760be 100644
--- a/src/partest/scala/tools/partest/CompilerTest.scala
+++ b/src/partest/scala/tools/partest/CompilerTest.scala
@@ -5,6 +5,7 @@
 
 package scala.tools.partest
 
+import scala.reflect.{mirror => rm}
 import scala.tools.nsc._
 
 /** For testing compiler internals directly.
@@ -29,13 +30,13 @@ abstract class CompilerTest extends DirectTest {
   // Override at least one of these...
   def code = ""
   def sources: List[String] = List(code)
-  
+
   // Utility functions
-  
+
   class MkType(sym: Symbol) {
-    def apply[M](implicit m1: Manifest[M]): Type =
+    def apply[M](implicit t: rm.TypeTag[M]): Type =
       if (sym eq NoSymbol) NoType
-      else appliedType(sym.typeConstructor, List(m1) map (x => manifestToType(x)))
+      else appliedType(sym, compilerTypeFromTag(t))
   }
   implicit def mkMkType(sym: Symbol) = new MkType(sym)
 
@@ -47,7 +48,7 @@ abstract class CompilerTest extends DirectTest {
     }
     loop(Set(), List(root))
   }
-  
+
   class SymsInPackage(pkgName: String) {
     def pkg     = getRequiredModule(pkgName)
     def classes = allMembers(pkg) filter (_.isClass)
diff --git a/src/partest/scala/tools/partest/ScaladocModelTest.scala b/src/partest/scala/tools/partest/ScaladocModelTest.scala
new file mode 100644
index 0000000000..142f2baea5
--- /dev/null
+++ b/src/partest/scala/tools/partest/ScaladocModelTest.scala
@@ -0,0 +1,146 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2011 LAMP/EPFL
+ * @author Vlad Ureche
+ */
+
+package scala.tools.partest
+
+import scala.tools.partest._
+import java.io._
+import scala.tools.nsc._
+import scala.tools.nsc.util.CommandLineParser
+import scala.tools.nsc.doc.{Settings, DocFactory, Universe}
+import scala.tools.nsc.doc.model._
+import scala.tools.nsc.reporters.ConsoleReporter
+
+/** A class for testing scaladoc model generation
+ *   - you need to specify the code in the `code` method
+ *   - you need to override the testModel method to test the model
+ *   - you may specify extra parameters to send to scaladoc in `scaladocSettings`
+ * {{{
+      import scala.tools.nsc.doc.model._
+      import scala.tools.partest.ScaladocModelTest
+
+      object Test extends ScaladocModelTest {
+
+        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._
+
+          // just need to check the member exists, access methods will throw an error if there's a problem
+          rootPackage._package("scala")._package("test")._class("C")._method("foo")
+        }
+      }
+ * }}}
+ */
+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"
+
+  override def show(): Unit = {
+    // 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 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 =>
+        println(e)
+        e.printStackTrace
+    }
+    // set err back to the real err handler
+    System.setErr(prevErr)
+  }
+
+  private[this] var settings: Settings = null
+
+  // create a new scaladoc compiler
+  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: Option[Universe] = newDocFactory.makeUniverse(Right(code))
+
+  // so we don't get the newSettings warning
+  override def isDebug = false
+
+
+  // finally, enable easy navigation inside the entities
+  object access {
+
+    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).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).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).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 _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) {
+      def _package(name: String): Package = getTheFirst(_packages(name), pack.qualifiedName + ".package(" + name + ")")
+      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(", ") + "]")
+    }
+  }
+}
diff --git a/src/partest/scala/tools/partest/SigTest.scala b/src/partest/scala/tools/partest/SigTest.scala
index 072ec006f9..999d901d21 100644
--- a/src/partest/scala/tools/partest/SigTest.scala
+++ b/src/partest/scala/tools/partest/SigTest.scala
@@ -20,31 +20,31 @@ trait SigTest {
 
   def isObjectMethodName(name: String) = classOf[Object].getMethods exists (_.getName == name)
 
-  def fields[T: ClassManifest](p: JField => Boolean) = {
-    val cl = classManifest[T].erasure
+  def fields[T: ClassTag](p: JField => Boolean) = {
+    val cl = classTag[T].erasure
     val fs = (cl.getFields ++ cl.getDeclaredFields).distinct sortBy (_.getName)
 
     fs filter p
   }
-  def methods[T: ClassManifest](p: JMethod => Boolean) = {
-    val cl = classManifest[T].erasure
+  def methods[T: ClassTag](p: JMethod => Boolean) = {
+    val cl = classTag[T].erasure
     val ms = (cl.getMethods ++ cl.getDeclaredMethods).distinct sortBy (x => (x.getName, x.isBridge))
 
     ms filter p
   }
-  def allFields[T: ClassManifest]()                = fields[T](_ => true)
-  def allMethods[T: ClassManifest]()               = methods[T](m => !isObjectMethodName(m.getName))
-  def fieldsNamed[T: ClassManifest](name: String)  = fields[T](_.getName == name)
-  def methodsNamed[T: ClassManifest](name: String) = methods[T](_.getName == name)
+  def allFields[T: ClassTag]()                = fields[T](_ => true)
+  def allMethods[T: ClassTag]()               = methods[T](m => !isObjectMethodName(m.getName))
+  def fieldsNamed[T: ClassTag](name: String)  = fields[T](_.getName == name)
+  def methodsNamed[T: ClassTag](name: String) = methods[T](_.getName == name)
 
-  def allGenericStrings[T: ClassManifest]() =
+  def allGenericStrings[T: ClassTag]() =
     (allMethods[T]() map mstr) ++ (allFields[T]() map fstr)
 
-  def genericStrings[T: ClassManifest](name: String) =
+  def genericStrings[T: ClassTag](name: String) =
     (methodsNamed[T](name) map mstr) ++ (fieldsNamed[T](name) map fstr)
 
-  def show[T: ClassManifest](name: String = "") = {
-    println(classManifest[T].erasure.getName)
+  def show[T: ClassTag](name: String = "") = {
+    println(classTag[T].erasure.getName)
     if (name == "") allGenericStrings[T]() foreach println
     else genericStrings[T](name) foreach println
   }
diff --git a/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala b/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
index fa533eeb10..8d239a84bd 100644
--- a/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
+++ b/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
@@ -96,6 +96,7 @@ class ConsoleFileManager extends FileManager {
       latestActorsFile  = dir / "lib/scala-actors.jar"
       latestCompFile    = dir / "lib/scala-compiler.jar"
       latestPartestFile = dir / "lib/scala-partest.jar"
+      latestFjbgFile    = testParent / "lib" / "fjbg.jar"
     }
     else {
       def setupQuick() {
diff --git a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala
index 85060ad633..fb3cab52c4 100644
--- a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala
+++ b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala
@@ -213,7 +213,12 @@ class ConsoleRunner extends DirectRunner {
    * @return (success count, failure count)
    */
   def testCheckAll(enabledSets: List[TestSet]): (Int, Int) = {
-    def kindOf(f: File) = (srcDir relativize Path(f).toCanonical).segments.head
+    def kindOf(f: File) = {
+      (srcDir relativize Path(f).toCanonical).segments match {
+        case (".." :: "scaladoc" :: xs) => xs.head
+        case xs => xs.head
+      }
+    }
 
     val (valid, invalid) = testFiles partition (x => testSetKinds contains kindOf(x))
     invalid foreach (x => NestUI.failure(
diff --git a/src/partest/scala/tools/partest/nest/TestFile.scala b/src/partest/scala/tools/partest/nest/TestFile.scala
index fc5792e886..1aa0a7baf6 100644
--- a/src/partest/scala/tools/partest/nest/TestFile.scala
+++ b/src/partest/scala/tools/partest/nest/TestFile.scala
@@ -35,7 +35,9 @@ abstract class TestFile(val kind: String) extends TestFileCommon {
     if (setOutDir)
       settings.outputDirs setSingleOutput setOutDirTo.path
 
-    // adding code.jar to the classpath (to provide Code.lift services for reification tests)
+    // adding codelib.jar to the classpath
+    // codelib provides the possibility to override standard reify
+    // this shields the massive amount of reification tests from changes in the API
     settings.classpath prepend PathSettings.srcCodeLib.toString
     if (propIsSet("java.class.path")) setProp("java.class.path", PathSettings.srcCodeLib.toString + ";" + propOrElse("java.class.path", ""))
 
diff --git a/src/partest/scala/tools/partest/nest/Worker.scala b/src/partest/scala/tools/partest/nest/Worker.scala
index cb6f2a0edc..00ee8ba857 100644
--- a/src/partest/scala/tools/partest/nest/Worker.scala
+++ b/src/partest/scala/tools/partest/nest/Worker.scala
@@ -181,7 +181,9 @@ class Worker(val fileManager: FileManager, params: TestRunParams) extends Actor
   //
   private def replaceSlashes(dir: File, s: String): String = {
     val base = (dir.getAbsolutePath + File.separator).replace('\\', '/')
-    s.replace('\\', '/').replaceAll("""\Q%s\E""" format base, "")
+    var regex = """\Q%s\E""" format base
+    if (isWin) regex = "(?i)" + regex
+    s.replace('\\', '/').replaceAll(regex, "")
   }
 
   private def currentFileString = {
@@ -521,9 +523,15 @@ class Worker(val fileManager: FileManager, params: TestRunParams) extends Actor
       runTestCommon(file, expectFailure = false)((logFile, outDir) => {
         val dir      = file.getParentFile
 
-        // adding code.jar to the classpath (to provide Code.lift services for reification tests)
-        execTest(outDir, logFile, PathSettings.srcCodeLib.toString) &&
-        diffCheck(compareOutput(dir, logFile))
+        // adding codelib.jar to the classpath
+        // codelib provides the possibility to override standard reify
+        // this shields the massive amount of reification tests from changes in the API
+        execTest(outDir, logFile, PathSettings.srcCodeLib.toString) && {
+          // cannot replace paths here since this also inverts slashes
+          // which affects a bunch of tests
+          //fileManager.mapFile(logFile, replaceSlashes(dir, _))
+          diffCheck(compareOutput(dir, logFile))
+        }
       })
 
     // Apache Ant 1.6 or newer