Merge remote-tracking branches 'axel22/feature/checkinit-transient' and 'jsuereth/mirrored-seq-extractors' into develop

41 files changed, 960 insertions, 176 deletions

diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check
index 196a769a17..243c9aa3be 100644..100755
--- a/test/files/jvm/interpreter.check
+++ b/test/files/jvm/interpreter.check
@@ -301,7 +301,7 @@ scala> <a>
 /></a>
 res8: scala.xml.Elem = 
 <a>
-<b c="c" d="dd"></b></a>
+<b c="c" d="dd"/></a>
 
 scala> 
 
diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check
index 81b68f0f5d..0b8055a6b9 100644
--- a/test/files/jvm/serialization.check
+++ b/test/files/jvm/serialization.check
@@ -192,8 +192,8 @@ x = TreeSet(1, 2, 3)
 y = TreeSet(1, 2, 3)
 x equals y: true, y equals x: true
 
-x = Ctrie(1 -> one, 2 -> two, 3 -> three)
-y = Ctrie(1 -> one, 2 -> two, 3 -> three)
+x = ConcurrentTrieMap(1 -> one, 2 -> two, 3 -> three)
+y = ConcurrentTrieMap(1 -> one, 2 -> two, 3 -> three)
 x equals y: true, y equals x: true
 
 x =  xml:src="hello"
@@ -287,8 +287,8 @@ x = ParHashMap(2 -> 4, 1 -> 2)
 y = ParHashMap(2 -> 4, 1 -> 2)
 x equals y: true, y equals x: true
 
-x = ParCtrie(1 -> 2, 2 -> 4)
-y = ParCtrie(1 -> 2, 2 -> 4)
+x = ParConcurrentTrieMap(1 -> 2, 2 -> 4)
+y = ParConcurrentTrieMap(1 -> 2, 2 -> 4)
 x equals y: true, y equals x: true
 
 x = ParHashSet(1, 2, 3)
diff --git a/test/files/jvm/serialization.scala b/test/files/jvm/serialization.scala
index 75daa8903d..1e89036f37 100644
--- a/test/files/jvm/serialization.scala
+++ b/test/files/jvm/serialization.scala
@@ -286,7 +286,7 @@ object Test3_mutable {
   import scala.collection.mutable.{
     ArrayBuffer, ArrayBuilder, ArraySeq, ArrayStack, BitSet, DoubleLinkedList,
     HashMap, HashSet, History, LinkedList, ListBuffer, Publisher, Queue,
-    Stack, StringBuilder, WrappedArray, TreeSet, Ctrie}
+    Stack, StringBuilder, WrappedArray, TreeSet, ConcurrentTrieMap}
 
   // in alphabetic order
   try {
@@ -386,9 +386,9 @@ object Test3_mutable {
     val _ts1: TreeSet[Int] = read(write(ts1))
     check(ts1, _ts1)
     
-    // Ctrie
-    val ct1 = Ctrie[Int, String]() ++= Array(1 -> "one", 2 -> "two", 3 -> "three")
-    val _ct1: Ctrie[Int, String] = read(write(ct1))
+    // ConcurrentTrieMap
+    val ct1 = ConcurrentTrieMap[Int, String]() ++= Array(1 -> "one", 2 -> "two", 3 -> "three")
+    val _ct1: ConcurrentTrieMap[Int, String] = read(write(ct1))
     check(ct1, _ct1)
   }
   catch {
@@ -613,9 +613,9 @@ object Test9_parallel {
     val _mpm: mutable.ParHashMap[Int, Int] = read(write(mpm))
     check(mpm, _mpm)
     
-    // mutable.ParCtrie
-    val mpc = mutable.ParCtrie(1 -> 2, 2 -> 4)
-    val _mpc: mutable.ParCtrie[Int, Int] = read(write(mpc))
+    // mutable.ParConcurrentTrieMap
+    val mpc = mutable.ParConcurrentTrieMap(1 -> 2, 2 -> 4)
+    val _mpc: mutable.ParConcurrentTrieMap[Int, Int] = read(write(mpc))
     check(mpc, _mpc)
     
     // mutable.ParHashSet
diff --git a/test/files/jvm/t0632.check b/test/files/jvm/t0632.check
index 3185410a75..681bc9da92 100644..100755
--- a/test/files/jvm/t0632.check
+++ b/test/files/jvm/t0632.check
@@ -1,12 +1,12 @@
-<foo x="&amp;"></foo>
-<foo x="&amp;"></foo>
-<foo x="&amp;"></foo>
-<foo x="&amp;"></foo>
-<foo x="&amp;amp;"></foo>
-<foo x="&amp;amp;"></foo>
-<foo x="&amp;amp;"></foo>
-<foo x="&amp;amp;"></foo>
-<foo x="&amp;&amp;"></foo>
-<foo x="&amp;&amp;"></foo>
-<foo x="&amp;&amp;"></foo>
-<foo x="&amp;&amp;"></foo>
+<foo x="&amp;"/>
+<foo x="&amp;"/>
+<foo x="&amp;"/>
+<foo x="&amp;"/>
+<foo x="&amp;amp;"/>
+<foo x="&amp;amp;"/>
+<foo x="&amp;amp;"/>
+<foo x="&amp;amp;"/>
+<foo x="&amp;&amp;"/>
+<foo x="&amp;&amp;"/>
+<foo x="&amp;&amp;"/>
+<foo x="&amp;&amp;"/>
diff --git a/test/files/jvm/t1118.check b/test/files/jvm/t1118.check
new file mode 100755
index 0000000000..d676b413c9
--- /dev/null
+++ b/test/files/jvm/t1118.check
@@ -0,0 +1,11 @@
+
+<hi/> <!-- literal short -->
+<there></there> <!-- literal long -->
+<guys who="you all"></guys> <!-- literal long with attribute-->
+<hows it="going"/> <!-- literal short with attribute -->
+<this>is pretty cool</this> <!-- literal not empty -->
+
+<emptiness></emptiness> <!--programmatic long-->
+<vide/> <!--programmatic short-->
+<elem attr="value"/> <!--programmatic short with attribute-->
+<elem2 attr2="value2"></elem2> <!--programmatic long with attribute-->
diff --git a/test/files/jvm/t1118.scala b/test/files/jvm/t1118.scala
new file mode 100755
index 0000000000..3c86547241
--- /dev/null
+++ b/test/files/jvm/t1118.scala
@@ -0,0 +1,21 @@
+import scala.xml._
+
+object Test {
+  def main(args: Array[String]) {
+    println(<xml:group>
+<hi/> <!-- literal short -->
+<there></there> <!-- literal long -->
+<guys who="you all"></guys> <!-- literal long with attribute-->
+<hows it="going"/> <!-- literal short with attribute -->
+<this>is pretty cool</this> <!-- literal not empty -->
+</xml:group>)
+
+    println(Elem(null, "emptiness", Null, TopScope, false) ++ Text(" ") ++ Comment("programmatic long"))
+
+    println(Elem(null, "vide", Null, TopScope, true) ++ Text(" ") ++ Comment("programmatic short"))
+
+    println(Elem(null, "elem", Attribute("attr", Text("value"), Null), TopScope, true) ++ Text(" ") ++ Comment ("programmatic short with attribute"))
+
+    println(Elem(null, "elem2", Attribute("attr2", Text("value2"), Null), TopScope, false) ++ Text(" ") ++ Comment ("programmatic long with attribute"))
+  }
+}
\ No newline at end of file
diff --git a/test/files/jvm/unittest_xml.scala b/test/files/jvm/unittest_xml.scala
index c03695f5c6..106334e625 100644
--- a/test/files/jvm/unittest_xml.scala
+++ b/test/files/jvm/unittest_xml.scala
@@ -89,7 +89,7 @@ object Test {
       assert(" a=\"2\" g=\"3\" j=\"2\" oo=\"2\"" == xml.Utility.sort(q.attributes).toString)
 
       val pp = new xml.PrettyPrinter(80,5)
-      assert("<a a=\"2\" g=\"3\" j=\"2\" oo=\"2\"></a>" == pp.format(q))
+      assert("<a a=\"2\" g=\"3\" j=\"2\" oo=\"2\"/>" == pp.format(q))
 
       <hi>
         <there/>
diff --git a/test/files/jvm/xml01.check b/test/files/jvm/xml01.check
index 5e82e9a729..d78e6df410 100644..100755
--- a/test/files/jvm/xml01.check
+++ b/test/files/jvm/xml01.check
@@ -3,6 +3,6 @@ xpath \
 xpath \\ DESCENDANTS
 <book><author>Peter Buneman</author><author>Dan Suciu</author><title>Data on ze web</title></book>
 -- group nodes
-<f><a></a><b></b><c></c></f>
-<a></a><f><a></a><b></b><c></c></f><a></a><b></b><c></c>
+<f><a/><b/><c/></f>
+<a/><f><a/><b/><c/></f><a/><b/><c/>
 attribute value normalization
diff --git a/test/files/jvm/xml03syntax.check b/test/files/jvm/xml03syntax.check
index 9fbedc2ae6..edcdbdd2ba 100644..100755
--- a/test/files/jvm/xml03syntax.check
+++ b/test/files/jvm/xml03syntax.check
@@ -22,5 +22,5 @@ true
 2
 4
 
-node=<elem key="<b>hello</b>"></elem>, key=Some(<b>hello</b>)
-node=<elem></elem>, key=None
+node=<elem key="<b>hello</b>"/>, key=Some(<b>hello</b>)
+node=<elem/>, key=None
diff --git a/test/files/jvm/xml05.check b/test/files/jvm/xml05.check
index 00e617c578..8d3e803bc8 100644
--- a/test/files/jvm/xml05.check
+++ b/test/files/jvm/xml05.check
@@ -4,7 +4,7 @@ Type :help for more information.
 scala> 
 
 scala> <city name="San Jos&eacute;"/>
-res0: scala.xml.Elem = <city name="San Jos&eacute;"></city>
+res0: scala.xml.Elem = <city name="San Jos&eacute;"/>
 
 scala> 
 
diff --git a/test/files/jvm/xmlattr.check b/test/files/jvm/xmlattr.check
index af80b60fb2..a87420d86c 100644
--- a/test/files/jvm/xmlattr.check
+++ b/test/files/jvm/xmlattr.check
@@ -14,5 +14,5 @@ true
 true
 true
 true
-<b x="&amp;"></b>
-<b x="&amp;"></b>
+<b x="&amp;"/>
+<b x="&amp;"/>
diff --git a/test/files/neg/t5572.check b/test/files/neg/t5572.check
new file mode 100644
index 0000000000..7b1e290861
--- /dev/null
+++ b/test/files/neg/t5572.check
@@ -0,0 +1,11 @@
+t5572.scala:16: error: type mismatch;
+ found   : B
+ required: A
+    Z.transf(a, b) match {
+             ^
+t5572.scala:18: error: type mismatch;
+ found   : A
+ required: B
+        run(sth, b)
+                 ^
+two errors found
diff --git a/test/files/neg/t5572.scala b/test/files/neg/t5572.scala
new file mode 100644
index 0000000000..2da1209c61
--- /dev/null
+++ b/test/files/neg/t5572.scala
@@ -0,0 +1,23 @@
+class A
+class B
+
+trait X
+
+object Z {
+  def transf(a: A, b: B): X = null
+}
+
+class Test {
+
+  def bar(): (A, B)
+
+  def foo {
+    val (b, a) = bar()
+    Z.transf(a, b) match {
+      case sth =>
+        run(sth, b)
+    }  
+  }
+
+  def run(x: X, z: B): Unit = ()
+}
diff --git a/test/files/pos/anyval-rangepos.scala b/test/files/pos/anyval-rangepos.scala
deleted file mode 100644
index 8d79793c0d..0000000000
--- a/test/files/pos/anyval-rangepos.scala
+++ /dev/null
@@ -1 +0,0 @@
-class Foo(val x: Double) extends AnyVal { }
diff --git a/test/files/pos/dotless-targs.scala b/test/files/pos/dotless-targs.scala
deleted file mode 100644
index 8337352d18..0000000000
--- a/test/files/pos/dotless-targs.scala
+++ /dev/null
@@ -1,12 +0,0 @@
-class A {
-  def fn1 = List apply 1
-  def fn2 = List apply[Int] 2
-
-  def f1 = "f1" isInstanceOf[String]
-
-  def g1 = "g1" toList
-  def g2 = "g2" toList 2
-  def g3 = "g3" apply 3
-
-  def h1 = List apply[List[Int]] (List(1), List(2)) mapConserve[List[Any]] (x => x)
-}
diff --git a/test/files/pos/anyval-rangepos.flags b/test/files/pos/rangepos.flags
index fcf951d907..fcf951d907 100644
--- a/test/files/pos/anyval-rangepos.flags
+++ b/test/files/pos/rangepos.flags
diff --git a/test/files/pos/rangepos.scala b/test/files/pos/rangepos.scala
new file mode 100644
index 0000000000..623b096acb
--- /dev/null
+++ b/test/files/pos/rangepos.scala
@@ -0,0 +1,5 @@
+class Foo(val x: Double) extends AnyVal { }
+
+object Pretty {
+  def f(s1: String) = new { def bar = 5 }
+}
diff --git a/test/files/pos/t5545/S_1.scala b/test/files/pos/t5545/S_1.scala
new file mode 100644
index 0000000000..59ec1fd851
--- /dev/null
+++ b/test/files/pos/t5545/S_1.scala
@@ -0,0 +1,4 @@
+trait F[@specialized(Int) T1, R] {
+  def f(v1: T1): R
+  def g = v1 => f(v1)
+}
diff --git a/test/files/pos/t5545/S_2.scala b/test/files/pos/t5545/S_2.scala
new file mode 100644
index 0000000000..59ec1fd851
--- /dev/null
+++ b/test/files/pos/t5545/S_2.scala
@@ -0,0 +1,4 @@
+trait F[@specialized(Int) T1, R] {
+  def f(v1: T1): R
+  def g = v1 => f(v1)
+}
diff --git a/test/files/run/compiler-asSeenFrom.check b/test/files/run/compiler-asSeenFrom.check
new file mode 100644
index 0000000000..f198e61072
--- /dev/null
+++ b/test/files/run/compiler-asSeenFrom.check
@@ -0,0 +1,323 @@
+class C {
+  type                       seen from prefix           is
+  ----                       ----------------           --
+  C[List[T3]]#I[T1]          D[A1]                      C[List[T3]]#I[A1]
+  C[List[T3]]#I[T1]          D[T3]                      C[List[T3]]#I[T3]
+  C[List[T3]]#J[T1]          D[A1]                      C[List[T3]]#J[A1]
+  C[List[T3]]#J[T1]          D[T3]                      C[List[T3]]#J[T3]
+  C[T1]#I[Int]               C[List[T3]]                C[List[T3]]#I[Int]
+  C[T1]#I[Int]               D[A1]                      C[A1]#I[Int]
+  C[T1]#I[Int]               D[T3]                      C[T3]#I[Int]
+  C[T1]#I[List[Int]]         C[List[T3]]                C[List[T3]]#I[List[Int]]
+  C[T1]#I[List[Int]]         D[A1]                      C[A1]#I[List[Int]]
+  C[T1]#I[List[Int]]         D[T3]                      C[T3]#I[List[Int]]
+  C[T1]#I[T1]                C[List[T3]]                C[List[T3]]#I[List[T3]]
+  C[T1]#I[T1]                D[A1]                      C[A1]#I[A1]
+  C[T1]#I[T1]                D[T3]                      C[T3]#I[T3]
+  C[T1]#I[T2]                C[List[T3]]                C[List[T3]]#I[T2]
+  C[T1]#I[T2]                D[A1]                      C[A1]#I[T2]
+  C[T1]#I[T2]                D[T3]                      C[T3]#I[T2]
+  C[T1]#I[T3]                C[List[T3]]                C[List[T3]]#I[T3]
+  C[T1]#I[T3]                D[A1]                      C[A1]#I[T3]
+  C[T1]#I[T3]                D[T3]                      C[T3]#I[T3]
+  C[T1]#I[T4]                C[List[T3]]                C[List[T3]]#I[T4]
+  C[T1]#I[T4]                D[A1]                      C[A1]#I[T4]
+  C[T1]#I[T4]                D[T3]                      C[T3]#I[T4]
+  C[T1]#J[Int]               C[List[T3]]                C[List[T3]]#J[Int]
+  C[T1]#J[Int]               D[A1]                      C[A1]#J[Int]
+  C[T1]#J[Int]               D[T3]                      C[T3]#J[Int]
+  C[T1]#J[List[Int]]         C[List[T3]]                C[List[T3]]#J[List[Int]]
+  C[T1]#J[List[Int]]         D[A1]                      C[A1]#J[List[Int]]
+  C[T1]#J[List[Int]]         D[T3]                      C[T3]#J[List[Int]]
+  C[T1]#J[T1]                C[List[T3]]                C[List[T3]]#J[List[T3]]
+  C[T1]#J[T1]                D[A1]                      C[A1]#J[A1]
+  C[T1]#J[T1]                D[T3]                      C[T3]#J[T3]
+  C[T1]#J[T2]                C[List[T3]]                C[List[T3]]#J[T2]
+  C[T1]#J[T2]                D[A1]                      C[A1]#J[T2]
+  C[T1]#J[T2]                D[T3]                      C[T3]#J[T2]
+  C[T1]#J[T3]                C[List[T3]]                C[List[T3]]#J[T3]
+  C[T1]#J[T3]                D[A1]                      C[A1]#J[T3]
+  C[T1]#J[T3]                D[T3]                      C[T3]#J[T3]
+  C[T1]#J[T4]                C[List[T3]]                C[List[T3]]#J[T4]
+  C[T1]#J[T4]                D[A1]                      C[A1]#J[T4]
+  C[T1]#J[T4]                D[T3]                      C[T3]#J[T4]
+  D[T3]#J[T1]                C[List[T3]]                D[T3]#J[List[T3]]
+  D[T3]#J[T1]                D[A1]                      D[T3]#J[A1]
+  D[A1]#J[T1]                C[List[T3]]                D[A1]#J[List[T3]]
+  D[A1]#J[T1]                D[T3]                      D[A1]#J[T3]
+}
+class D {
+  type                       seen from prefix           is
+  ----                       ----------------           --
+  C[List[T3]]#I[Int]         D[A1]                      C[List[A1]]#I[Int]
+  C[List[T3]]#I[List[Int]]   D[A1]                      C[List[A1]]#I[List[Int]]
+  C[List[T3]]#I[T1]          D[A1]                      C[List[A1]]#I[T1]
+  C[List[T3]]#I[T2]          D[A1]                      C[List[A1]]#I[T2]
+  C[List[T3]]#I[T3]          D[A1]                      C[List[A1]]#I[A1]
+  C[List[T3]]#I[T4]          D[A1]                      C[List[A1]]#I[T4]
+  C[List[T3]]#J[Int]         D[A1]                      C[List[A1]]#J[Int]
+  C[List[T3]]#J[List[Int]]   D[A1]                      C[List[A1]]#J[List[Int]]
+  C[List[T3]]#J[T1]          D[A1]                      C[List[A1]]#J[T1]
+  C[List[T3]]#J[T2]          D[A1]                      C[List[A1]]#J[T2]
+  C[List[T3]]#J[T3]          D[A1]                      C[List[A1]]#J[A1]
+  C[List[T3]]#J[T4]          D[A1]                      C[List[A1]]#J[T4]
+  C[T1]#I[T3]                D[A1]                      C[T1]#I[A1]
+  C[T1]#J[T3]                D[A1]                      C[T1]#J[A1]
+  D[T3]#J[Int]               D[A1]                      D[A1]#J[Int]
+  D[T3]#J[List[Int]]         D[A1]                      D[A1]#J[List[Int]]
+  D[T3]#J[T1]                D[A1]                      D[A1]#J[T1]
+  D[T3]#J[T2]                D[A1]                      D[A1]#J[T2]
+  D[T3]#J[T3]                D[A1]                      D[A1]#J[A1]
+  D[T3]#J[T4]                D[A1]                      D[A1]#J[T4]
+}
+class I {
+  type                       seen from prefix           is
+  ----                       ----------------           --
+  C[List[T3]]#I[T1]          D.this.J[T4]               C[List[T3]]#I[List[T3]]
+  C[List[T3]]#I[T1]          Z.dZ.J[A2]                 C[List[T3]]#I[List[A1]]
+  C[List[T3]]#I[T1]          Z.dZ.J[P]                  C[List[T3]]#I[List[A1]]
+  C[List[T3]]#I[T2]          D.this.J[T4]               C[List[T3]]#I[T4]
+  C[List[T3]]#I[T2]          Z.dZ.J[A2]                 C[List[T3]]#I[A2]
+  C[List[T3]]#I[T2]          Z.dZ.J[P]                  C[List[T3]]#I[P]
+  C[List[T3]]#J[T1]          D.this.J[T4]               C[List[T3]]#J[List[T3]]
+  C[List[T3]]#J[T1]          Z.dZ.J[A2]                 C[List[T3]]#J[List[A1]]
+  C[List[T3]]#J[T1]          Z.dZ.J[P]                  C[List[T3]]#J[List[A1]]
+  C[List[T3]]#J[T2]          D.this.J[T4]               C[List[T3]]#J[T4]
+  C[List[T3]]#J[T2]          Z.dZ.J[A2]                 C[List[T3]]#J[A2]
+  C[List[T3]]#J[T2]          Z.dZ.J[P]                  C[List[T3]]#J[P]
+  C[T1]#I[Int]               D.this.J[T4]               C[List[T3]]#I[Int]
+  C[T1]#I[Int]               Z.dZ.J[A2]                 C[List[A1]]#I[Int]
+  C[T1]#I[Int]               Z.dZ.J[P]                  C[List[A1]]#I[Int]
+  C[T1]#I[List[Int]]         D.this.J[T4]               C[List[T3]]#I[List[Int]]
+  C[T1]#I[List[Int]]         Z.dZ.J[A2]                 C[List[A1]]#I[List[Int]]
+  C[T1]#I[List[Int]]         Z.dZ.J[P]                  C[List[A1]]#I[List[Int]]
+  C[T1]#I[T1]                D.this.J[T4]               C[List[T3]]#I[List[T3]]
+  C[T1]#I[T1]                Z.dZ.J[A2]                 C[List[A1]]#I[List[A1]]
+  C[T1]#I[T1]                Z.dZ.J[P]                  C[List[A1]]#I[List[A1]]
+  C[T1]#I[T2]                D.this.J[T4]               C[List[T3]]#I[T4]
+  C[T1]#I[T2]                Z.dZ.J[A2]                 C[List[A1]]#I[A2]
+  C[T1]#I[T2]                Z.dZ.J[P]                  C[List[A1]]#I[P]
+  C[T1]#I[T3]                D.this.J[T4]               C[List[T3]]#I[T3]
+  C[T1]#I[T3]                Z.dZ.J[A2]                 C[List[A1]]#I[T3]
+  C[T1]#I[T3]                Z.dZ.J[P]                  C[List[A1]]#I[T3]
+  C[T1]#I[T4]                D.this.J[T4]               C[List[T3]]#I[T4]
+  C[T1]#I[T4]                Z.dZ.J[A2]                 C[List[A1]]#I[T4]
+  C[T1]#I[T4]                Z.dZ.J[P]                  C[List[A1]]#I[T4]
+  C[T1]#J[Int]               D.this.J[T4]               C[List[T3]]#J[Int]
+  C[T1]#J[Int]               Z.dZ.J[A2]                 C[List[A1]]#J[Int]
+  C[T1]#J[Int]               Z.dZ.J[P]                  C[List[A1]]#J[Int]
+  C[T1]#J[List[Int]]         D.this.J[T4]               C[List[T3]]#J[List[Int]]
+  C[T1]#J[List[Int]]         Z.dZ.J[A2]                 C[List[A1]]#J[List[Int]]
+  C[T1]#J[List[Int]]         Z.dZ.J[P]                  C[List[A1]]#J[List[Int]]
+  C[T1]#J[T1]                D.this.J[T4]               C[List[T3]]#J[List[T3]]
+  C[T1]#J[T1]                Z.dZ.J[A2]                 C[List[A1]]#J[List[A1]]
+  C[T1]#J[T1]                Z.dZ.J[P]                  C[List[A1]]#J[List[A1]]
+  C[T1]#J[T2]                D.this.J[T4]               C[List[T3]]#J[T4]
+  C[T1]#J[T2]                Z.dZ.J[A2]                 C[List[A1]]#J[A2]
+  C[T1]#J[T2]                Z.dZ.J[P]                  C[List[A1]]#J[P]
+  C[T1]#J[T3]                D.this.J[T4]               C[List[T3]]#J[T3]
+  C[T1]#J[T3]                Z.dZ.J[A2]                 C[List[A1]]#J[T3]
+  C[T1]#J[T3]                Z.dZ.J[P]                  C[List[A1]]#J[T3]
+  C[T1]#J[T4]                D.this.J[T4]               C[List[T3]]#J[T4]
+  C[T1]#J[T4]                Z.dZ.J[A2]                 C[List[A1]]#J[T4]
+  C[T1]#J[T4]                Z.dZ.J[P]                  C[List[A1]]#J[T4]
+  D[T3]#J[T1]                D.this.J[T4]               D[T3]#J[List[T3]]
+  D[T3]#J[T1]                Z.dZ.J[A2]                 D[T3]#J[List[A1]]
+  D[T3]#J[T1]                Z.dZ.J[P]                  D[T3]#J[List[A1]]
+  D[T3]#J[T2]                D.this.J[T4]               D[T3]#J[T4]
+  D[T3]#J[T2]                Z.dZ.J[A2]                 D[T3]#J[A2]
+  D[T3]#J[T2]                Z.dZ.J[P]                  D[T3]#J[P]
+  D[A1]#J[T1]                D.this.J[T4]               D[A1]#J[List[T3]]
+  D[A1]#J[T1]                Z.dZ.J[A2]                 D[A1]#J[List[A1]]
+  D[A1]#J[T1]                Z.dZ.J[P]                  D[A1]#J[List[A1]]
+  D[A1]#J[T2]                D.this.J[T4]               D[A1]#J[T4]
+  D[A1]#J[T2]                Z.dZ.J[A2]                 D[A1]#J[A2]
+  D[A1]#J[T2]                Z.dZ.J[P]                  D[A1]#J[P]
+}
+class J {
+  type                       seen from prefix           is
+  ----                       ----------------           --
+  C[List[T3]]#I[Int]         Z.dZ.J[A2]                 C[List[A1]]#I[Int]
+  C[List[T3]]#I[Int]         Z.dZ.J[P]                  C[List[A1]]#I[Int]
+  C[List[T3]]#I[List[Int]]   Z.dZ.J[A2]                 C[List[A1]]#I[List[Int]]
+  C[List[T3]]#I[List[Int]]   Z.dZ.J[P]                  C[List[A1]]#I[List[Int]]
+  C[List[T3]]#I[T1]          Z.dZ.J[A2]                 C[List[A1]]#I[T1]
+  C[List[T3]]#I[T1]          Z.dZ.J[P]                  C[List[A1]]#I[T1]
+  C[List[T3]]#I[T2]          Z.dZ.J[A2]                 C[List[A1]]#I[T2]
+  C[List[T3]]#I[T2]          Z.dZ.J[P]                  C[List[A1]]#I[T2]
+  C[List[T3]]#I[T3]          Z.dZ.J[A2]                 C[List[A1]]#I[A1]
+  C[List[T3]]#I[T3]          Z.dZ.J[P]                  C[List[A1]]#I[A1]
+  C[List[T3]]#I[T4]          Z.dZ.J[A2]                 C[List[A1]]#I[A2]
+  C[List[T3]]#I[T4]          Z.dZ.J[P]                  C[List[A1]]#I[P]
+  C[List[T3]]#J[Int]         Z.dZ.J[A2]                 C[List[A1]]#J[Int]
+  C[List[T3]]#J[Int]         Z.dZ.J[P]                  C[List[A1]]#J[Int]
+  C[List[T3]]#J[List[Int]]   Z.dZ.J[A2]                 C[List[A1]]#J[List[Int]]
+  C[List[T3]]#J[List[Int]]   Z.dZ.J[P]                  C[List[A1]]#J[List[Int]]
+  C[List[T3]]#J[T1]          Z.dZ.J[A2]                 C[List[A1]]#J[T1]
+  C[List[T3]]#J[T1]          Z.dZ.J[P]                  C[List[A1]]#J[T1]
+  C[List[T3]]#J[T2]          Z.dZ.J[A2]                 C[List[A1]]#J[T2]
+  C[List[T3]]#J[T2]          Z.dZ.J[P]                  C[List[A1]]#J[T2]
+  C[List[T3]]#J[T3]          Z.dZ.J[A2]                 C[List[A1]]#J[A1]
+  C[List[T3]]#J[T3]          Z.dZ.J[P]                  C[List[A1]]#J[A1]
+  C[List[T3]]#J[T4]          Z.dZ.J[A2]                 C[List[A1]]#J[A2]
+  C[List[T3]]#J[T4]          Z.dZ.J[P]                  C[List[A1]]#J[P]
+  C[T1]#I[T3]                Z.dZ.J[A2]                 C[T1]#I[A1]
+  C[T1]#I[T3]                Z.dZ.J[P]                  C[T1]#I[A1]
+  C[T1]#I[T4]                Z.dZ.J[A2]                 C[T1]#I[A2]
+  C[T1]#I[T4]                Z.dZ.J[P]                  C[T1]#I[P]
+  C[T1]#J[T3]                Z.dZ.J[A2]                 C[T1]#J[A1]
+  C[T1]#J[T3]                Z.dZ.J[P]                  C[T1]#J[A1]
+  C[T1]#J[T4]                Z.dZ.J[A2]                 C[T1]#J[A2]
+  C[T1]#J[T4]                Z.dZ.J[P]                  C[T1]#J[P]
+  D[T3]#J[Int]               Z.dZ.J[A2]                 D[A1]#J[Int]
+  D[T3]#J[Int]               Z.dZ.J[P]                  D[A1]#J[Int]
+  D[T3]#J[List[Int]]         Z.dZ.J[A2]                 D[A1]#J[List[Int]]
+  D[T3]#J[List[Int]]         Z.dZ.J[P]                  D[A1]#J[List[Int]]
+  D[T3]#J[T1]                Z.dZ.J[A2]                 D[A1]#J[T1]
+  D[T3]#J[T1]                Z.dZ.J[P]                  D[A1]#J[T1]
+  D[T3]#J[T2]                Z.dZ.J[A2]                 D[A1]#J[T2]
+  D[T3]#J[T2]                Z.dZ.J[P]                  D[A1]#J[T2]
+  D[T3]#J[T3]                Z.dZ.J[A2]                 D[A1]#J[A1]
+  D[T3]#J[T3]                Z.dZ.J[P]                  D[A1]#J[A1]
+  D[T3]#J[T4]                Z.dZ.J[A2]                 D[A1]#J[A2]
+  D[T3]#J[T4]                Z.dZ.J[P]                  D[A1]#J[P]
+  D[A1]#J[T3]                Z.dZ.J[A2]                 D[A1]#J[A1]
+  D[A1]#J[T3]                Z.dZ.J[P]                  D[A1]#J[A1]
+  D[A1]#J[T4]                Z.dZ.J[A2]                 D[A1]#J[A2]
+  D[A1]#J[T4]                Z.dZ.J[P]                  D[A1]#J[P]
+}
+class D { // after parser
+  private val cD: ll.C[List[T3]]
+  val cD: ll.C[List[T3]]
+}
+
+class D { // after uncurry
+  private val cD: ll.C[List[T3]]
+  val cD(): ll.C[List[T3]]
+}
+
+class D { // after erasure
+  private val cD: ll.C
+  val cD(): ll.C
+}
+
+object Z { // after parser
+  def kz[P <: ll.Z.dZ.J[ll.A2]]: ll.Z.dZ.J[P]
+  private val jZ: ll.Z.dZ.J[ll.A2]
+  val jZ: ll.Z.dZ.J[ll.A2]
+  private val dZ: ll.D[ll.A1]
+  val dZ: ll.D[ll.A1]
+}
+
+object Z { // after uncurry
+  def kz[P <: ll.Z.dZ.J[ll.A2]](): ll.Z.dZ.J[P]
+  private val jZ: ll.Z.dZ.J[ll.A2]
+  val jZ(): ll.Z.dZ.J[ll.A2]
+  private val dZ: ll.D[ll.A1]
+  val dZ(): ll.D[ll.A1]
+}
+
+object Z { // after erasure
+  def kz(): ll.D#J
+  private val jZ: ll.D#J
+  val jZ(): ll.D#J
+  private val dZ: ll.D
+  val dZ(): ll.D
+}
+
+object Z { // after flatten
+  def kz(): ll.D#D$J
+  private val jZ: ll.D#D$J
+  val jZ(): ll.D#D$J
+  private val dZ: ll.D
+  val dZ(): ll.D
+}
+
+value dZ { // after parser
+  private val cD: ll.C[List[T3]]
+  val cD: ll.C[List[T3]]
+}
+
+value dZ { // after parser
+  private val cD: ll.C[List[T3]]
+  val cD: ll.C[List[T3]]
+}
+
+value dZ { // after uncurry
+  private val cD: ll.C[List[T3]]
+  val cD(): ll.C[List[T3]]
+}
+
+value dZ { // after erasure
+  private val cD: ll.C
+  val cD(): ll.C
+}
+
+value jZ { // after parser
+  def thisI(): I.this.type
+  def thisC(): C.this.type
+  def t2(): T2
+  def t1(): T1
+}
+
+value jZ { // after parser
+  def thisI(): I.this.type
+  def thisC(): C.this.type
+  def t2(): T2
+  def t1(): T1
+}
+
+value jZ { // after explicitouter
+  protected val $outer: D.this.type
+  val ll$D$J$$$outer(): D.this.type
+  val ll$C$I$$$outer(): C.this.type
+  def thisI(): I.this.type
+  def thisC(): C.this.type
+  def t2(): T2
+  def t1(): T1
+}
+
+value jZ { // after erasure
+  protected val $outer: ll.D
+  val ll$D$J$$$outer(): ll.D
+  protected val $outer: ll.C
+  val ll$C$I$$$outer(): ll.C
+  def thisI(): ll.C#I
+  def thisC(): ll.C
+  def t2(): Object
+  def t1(): Object
+}
+
+value jZ { // after flatten
+  protected val $outer: ll.D
+  val ll$D$J$$$outer(): ll.D
+  protected val $outer: ll.C
+  val ll$C$I$$$outer(): ll.C
+  def thisI(): ll.C#C$I
+  def thisC(): ll.C
+  def t2(): Object
+  def t1(): Object
+}
+
+method kz { // after parser
+  def thisI(): I.this.type
+  def thisC(): C.this.type
+  def t2(): T2
+  def t1(): T1
+}
+
+value $outer { // after parser
+  private val cD: ll.C[List[T3]]
+  val cD: ll.C[List[T3]]
+}
+
+value $outer { // after uncurry
+  private val cD: ll.C[List[T3]]
+  val cD(): ll.C[List[T3]]
+}
+
+value $outer { // after erasure
+  private val cD: ll.C
+  val cD(): ll.C
+}
+
diff --git a/test/files/run/compiler-asSeenFrom.scala b/test/files/run/compiler-asSeenFrom.scala
new file mode 100644
index 0000000000..1fc3a5ee71
--- /dev/null
+++ b/test/files/run/compiler-asSeenFrom.scala
@@ -0,0 +1,122 @@
+import scala.tools.nsc._
+import scala.tools.partest.CompilerTest
+import scala.collection.{ mutable, immutable, generic }
+
+/** It's too messy but it's better than not having it.
+ */
+object Test extends CompilerTest {
+  import global._
+  import definitions._
+
+  override def sources = List(lambdaLift)
+  def lambdaLift = """
+package ll {
+  class A1
+  class A2
+  class X
+  class C[T1]() {
+    class I[T2]() {
+      def t1(): T1 = ???
+      def t2(): T2 = ???
+      def thisC(): C.this.type = ???
+      def thisI(): I.this.type = ???
+    }
+  }
+  class D[T3]() extends C[T3]() {
+    val cD: C[List[T3]] = ???
+    class J[T4]() extends cD.I[T4]()
+  }
+  object Z {
+    val dZ:    D[A1] = ???
+    val jZ: dZ.J[A2] = ???
+
+    def kz[P <: dZ.J[A2]]: dZ.J[P] = ???
+  }
+}
+"""
+
+  object syms extends SymsInPackage("ll") {
+    def isPossibleEnclosure(encl: Symbol, sym: Symbol) = sym.enclClassChain drop 1 exists (_ isSubClass encl)
+    def isInterestingPrefix(pre: Type) = pre.typeConstructor.typeParams.nonEmpty && pre.members.exists(_.isType)
+
+    def asSeenPrefixes  = tpes map (_.finalResultType) distinct
+    def typeRefPrefixes = asSeenPrefixes filter isInterestingPrefix
+
+    def nestsIn(outer: Symbol) = classes filter (c => c.enclClassChain drop 1 exists(_ isSubClass outer))
+    def typeRefs(targs: List[Type]) = (
+      for (p <- typeRefPrefixes ; c <- classes filter (isPossibleEnclosure(p.typeSymbol, _)) ; a <- targs) yield
+        typeRef(p, c, List(a))
+    )
+    
+    val wfmt      = "%-" + 25 + "s"
+    def to_s(x: Any): String    = wfmt.format(x.toString.replaceAll("""\bll\.""", ""))
+    
+    def fmt(args: Any*): String = {
+      (args map to_s mkString "  ").replaceAll("""\s+$""", "")
+    }
+    def fname(sym: Symbol) = {
+      val p = "" + sym.owner.name
+      val x = if (sym.owner.isPackageClass || sym.owner.isModuleClass || sym.owner.isTerm) "." else "#"
+      sym.kindString + " " + p + x + sym.name
+    }
+
+    def permuteAsSeenFrom(targs: List[Type]) = (
+      for { 
+        tp <- typeRefs(targs filterNot (_ eq NoType))
+        prefix <- asSeenPrefixes
+        if tp.prefix != prefix
+        site <- classes
+        seen = tp.asSeenFrom(prefix, site)
+        if tp != seen
+        if !seen.isInstanceOf[ExistentialType]
+      }
+      yield ((site, tp, prefix, seen))
+    )
+    
+    def block(label: Any)(lines: List[String]): List[String] = {
+      val first = "" + label + " {"
+      val  last = "}"
+      
+      first +: lines.map("  " + _) :+ last
+    }
+
+    def permute(targs: List[Type]): List[String] = {
+      permuteAsSeenFrom(targs).groupBy(_._1).toList.sortBy(_._1.toString) flatMap {
+        case (site, xs) =>
+          block(fmt(site)) {
+            fmt("type", "seen from prefix", "is") :: 
+            fmt("----", "----------------", "--") :: {
+              xs.groupBy(_._2).toList.sortBy(_._1.toString) flatMap {
+                case (tp, ys) =>
+                  (ys map { case (_, _, prefix, seen) => fmt(tp, prefix, seen) }).sorted.distinct
+              }
+            }
+          }
+      }
+    }
+  }
+  
+  def pretty(xs: List[_]) = if (xs.isEmpty) "" else xs.mkString("\n  ", "\n  ", "\n")
+
+  def signaturesIn(info: Type): List[String] = (
+    info.members 
+      filterNot (s => s.isType || s.owner == ObjectClass || s.owner == AnyClass || s.isConstructor)
+      map (_.defString)
+  )
+  
+  def check(source: String, unit: global.CompilationUnit) = {
+    import syms._
+
+    afterTyper {
+      val typeArgs = List[Type](IntClass.tpe, ListClass[Int]) ++ tparams.map(_.tpe)
+      permute(typeArgs) foreach println
+    }
+    for (x <- classes ++ terms) {
+      afterEachPhase(signaturesIn(x.tpe)) collect {
+        case (ph, sigs) if sigs.nonEmpty =>
+          println(sigs.mkString(x + " { // after " + ph + "\n  ", "\n  ", "\n}\n"))
+      }
+    }
+    true
+  }
+}
diff --git a/test/files/run/ctries/concmap.scala b/test/files/run/ctries/concmap.scala
index d73e33182a..bf8cc9d12f 100644
--- a/test/files/run/ctries/concmap.scala
+++ b/test/files/run/ctries/concmap.scala
@@ -1,7 +1,7 @@
 
 
 
-import collection.mutable.Ctrie
+import collection.mutable.ConcurrentTrieMap
 
 
 object ConcurrentMapSpec extends Spec {
@@ -11,13 +11,13 @@ object ConcurrentMapSpec extends Spec {
   
   def test() {
     "support put" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until initsz) assert(ct.put(new Wrap(i), i) == None)
       for (i <- 0 until initsz) assert(ct.put(new Wrap(i), -i) == Some(i))
     }
     
     "support put if absent" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until initsz) ct.update(new Wrap(i), i)
       for (i <- 0 until initsz) assert(ct.putIfAbsent(new Wrap(i), -i) == Some(i))
       for (i <- 0 until initsz) assert(ct.putIfAbsent(new Wrap(i), -i) == Some(i))
@@ -26,7 +26,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "support remove if mapped to a specific value" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until initsz) ct.update(new Wrap(i), i)
       for (i <- 0 until initsz) assert(ct.remove(new Wrap(i), -i - 1) == false)
       for (i <- 0 until initsz) assert(ct.remove(new Wrap(i), i) == true)
@@ -34,7 +34,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "support replace if mapped to a specific value" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until initsz) ct.update(new Wrap(i), i)
       for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), -i - 1, -i - 2) == false)
       for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), i, -i - 2) == true)
@@ -43,7 +43,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "support replace if present" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until initsz) ct.update(new Wrap(i), i)
       for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), -i) == Some(i))
       for (i <- 0 until initsz) assert(ct.replace(new Wrap(i), i) == Some(-i))
@@ -56,7 +56,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "support replace if mapped to a specific value, using several threads" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       val sz = 55000
       for (i <- 0 until sz) ct.update(new Wrap(i), i)
       
@@ -89,7 +89,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "support put if absent, several threads" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       val sz = 110000
       
       class Updater(offs: Int) extends Thread {
@@ -110,7 +110,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "support remove if mapped to a specific value, several threads" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       val sz = 55000
       for (i <- 0 until sz) ct.update(new Wrap(i), i)
       
@@ -132,7 +132,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "have all or none of the elements depending on the oddity" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       val sz = 65000
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       
@@ -165,7 +165,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "compute size correctly" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       val sz = 36450
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       
@@ -174,7 +174,7 @@ object ConcurrentMapSpec extends Spec {
     }
     
     "compute size correctly in parallel" in {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       val sz = 36450
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       val pct = ct.par
diff --git a/test/files/run/ctries/iterator.scala b/test/files/run/ctries/iterator.scala
index 85a6ab7623..dbfab6b8a9 100644
--- a/test/files/run/ctries/iterator.scala
+++ b/test/files/run/ctries/iterator.scala
@@ -3,7 +3,7 @@
 
 
 import collection._
-import collection.mutable.Ctrie
+import collection.mutable.ConcurrentTrieMap
 
 
 
@@ -11,7 +11,7 @@ object IteratorSpec extends Spec {
   
   def test() {
     "work for an empty trie" in {
-      val ct = new Ctrie
+      val ct = new ConcurrentTrieMap
       val it = ct.iterator
       
       it.hasNext shouldEqual (false)
@@ -19,7 +19,7 @@ object IteratorSpec extends Spec {
     }
     
     def nonEmptyIteratorCheck(sz: Int) {
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct.put(new Wrap(i), i)
       
       val it = ct.iterator
@@ -84,7 +84,7 @@ object IteratorSpec extends Spec {
     }
     
     def nonEmptyCollideCheck(sz: Int) {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until sz) ct.put(new DumbHash(i), i)
       
       val it = ct.iterator
@@ -144,7 +144,7 @@ object IteratorSpec extends Spec {
       val W = 15
       val S = 5
       val checks = 5
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct.put(new Wrap(i), i)
       
       class Modifier extends Thread {
@@ -156,7 +156,7 @@ object IteratorSpec extends Spec {
         }
       }
       
-      def consistentIteration(ct: Ctrie[Wrap, Int], checks: Int) {
+      def consistentIteration(ct: ConcurrentTrieMap[Wrap, Int], checks: Int) {
         class Iter extends Thread {
           override def run() {
             val snap = ct.readOnlySnapshot()
@@ -185,7 +185,7 @@ object IteratorSpec extends Spec {
       val sgroupsize = 10
       val sgroupnum = 5
       val removerslowdown = 50
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct.put(new Wrap(i), i)
       
       class Remover extends Thread {
@@ -227,7 +227,7 @@ object IteratorSpec extends Spec {
       val sgroupsize = 10
       val sgroupnum = 10
       val inserterslowdown = 50
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       
       class Inserter extends Thread {
         override def run() {
@@ -265,7 +265,7 @@ object IteratorSpec extends Spec {
     
     "work on a yet unevaluated snapshot" in {
       val sz = 50000
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct.update(new Wrap(i), i)
       
       val snap = ct.snapshot()
@@ -276,7 +276,7 @@ object IteratorSpec extends Spec {
     
     "be duplicated" in {
       val sz = 50
-      val ct = collection.parallel.mutable.ParCtrie((0 until sz) zip (0 until sz): _*)
+      val ct = collection.parallel.mutable.ParConcurrentTrieMap((0 until sz) zip (0 until sz): _*)
       val it = ct.splitter
       for (_ <- 0 until (sz / 2)) it.next()
       val dupit = it.dup
diff --git a/test/files/run/ctries/lnode.scala b/test/files/run/ctries/lnode.scala
index 88cbeed1f6..e480795956 100644
--- a/test/files/run/ctries/lnode.scala
+++ b/test/files/run/ctries/lnode.scala
@@ -1,7 +1,7 @@
 
 
 
-import collection.mutable.Ctrie
+import collection.mutable.ConcurrentTrieMap
 
 
 object LNodeSpec extends Spec {
@@ -11,19 +11,19 @@ object LNodeSpec extends Spec {
   
   def test() {
     "accept elements with the same hash codes" in {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until initsz) ct.update(new DumbHash(i), i)
     }
     
     "lookup elements with the same hash codes" in {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until initsz) ct.update(new DumbHash(i), i)
       for (i <- 0 until initsz) assert(ct.get(new DumbHash(i)) == Some(i))
       for (i <- initsz until secondsz) assert(ct.get(new DumbHash(i)) == None)
     }
     
     "remove elements with the same hash codes" in {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until initsz) ct.update(new DumbHash(i), i)
       for (i <- 0 until initsz) {
         val remelem = ct.remove(new DumbHash(i))
@@ -33,7 +33,7 @@ object LNodeSpec extends Spec {
     }
     
     "put elements with the same hash codes if absent" in {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until initsz) ct.put(new DumbHash(i), i)
       for (i <- 0 until initsz) assert(ct.lookup(new DumbHash(i)) == i)
       for (i <- 0 until initsz) assert(ct.putIfAbsent(new DumbHash(i), i) == Some(i))
@@ -42,7 +42,7 @@ object LNodeSpec extends Spec {
     }
     
     "replace elements with the same hash codes" in {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until initsz) assert(ct.put(new DumbHash(i), i) == None)
       for (i <- 0 until initsz) assert(ct.lookup(new DumbHash(i)) == i)
       for (i <- 0 until initsz) assert(ct.replace(new DumbHash(i), -i) == Some(i))
@@ -51,7 +51,7 @@ object LNodeSpec extends Spec {
     }
     
     "remove elements with the same hash codes if mapped to a specific value" in {
-      val ct = new Ctrie[DumbHash, Int]
+      val ct = new ConcurrentTrieMap[DumbHash, Int]
       for (i <- 0 until initsz) assert(ct.put(new DumbHash(i), i) == None)
       for (i <- 0 until initsz) assert(ct.remove(new DumbHash(i), i) == true)
     }
diff --git a/test/files/run/ctries/snapshot.scala b/test/files/run/ctries/snapshot.scala
index 69073d3f06..3c816130b3 100644
--- a/test/files/run/ctries/snapshot.scala
+++ b/test/files/run/ctries/snapshot.scala
@@ -3,7 +3,7 @@
 
 
 import collection._
-import collection.mutable.Ctrie
+import collection.mutable.ConcurrentTrieMap
 
 
 
@@ -11,11 +11,11 @@ object SnapshotSpec extends Spec {
   
   def test() {
     "support snapshots" in {
-      val ctn = new Ctrie
+      val ctn = new ConcurrentTrieMap
       ctn.snapshot()
       ctn.readOnlySnapshot()
       
-      val ct = new Ctrie[Int, Int]
+      val ct = new ConcurrentTrieMap[Int, Int]
       for (i <- 0 until 100) ct.put(i, i)
       ct.snapshot()
       ct.readOnlySnapshot()
@@ -24,7 +24,7 @@ object SnapshotSpec extends Spec {
     "empty 2 quiescent snapshots in isolation" in {
       val sz = 4000
       
-      class Worker(trie: Ctrie[Wrap, Int]) extends Thread {
+      class Worker(trie: ConcurrentTrieMap[Wrap, Int]) extends Thread {
         override def run() {
           for (i <- 0 until sz) {
             assert(trie.remove(new Wrap(i)) == Some(i))
@@ -35,7 +35,7 @@ object SnapshotSpec extends Spec {
         }
       }
       
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct.put(new Wrap(i), i)
       val snapt = ct.snapshot()
       
@@ -96,7 +96,7 @@ object SnapshotSpec extends Spec {
     }
     
     // traverses the trie `rep` times and modifies each entry
-    class Modifier(trie: Ctrie[Wrap, Int], index: Int, rep: Int, sz: Int) extends Thread {
+    class Modifier(trie: ConcurrentTrieMap[Wrap, Int], index: Int, rep: Int, sz: Int) extends Thread {
       setName("Modifier %d".format(index))
       
       override def run() {
@@ -110,7 +110,7 @@ object SnapshotSpec extends Spec {
     }
     
     // removes all the elements from the trie
-    class Remover(trie: Ctrie[Wrap, Int], index: Int, totremovers: Int, sz: Int) extends Thread {
+    class Remover(trie: ConcurrentTrieMap[Wrap, Int], index: Int, totremovers: Int, sz: Int) extends Thread {
       setName("Remover %d".format(index))
       
       override def run() {
@@ -123,7 +123,7 @@ object SnapshotSpec extends Spec {
       val N = 100
       val W = 10
       
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       val readonly = ct.readOnlySnapshot()
       val threads = for (i <- 0 until W) yield new Modifier(ct, i, N, sz)
@@ -141,7 +141,7 @@ object SnapshotSpec extends Spec {
       val W = 100
       val S = 5000
       
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       val threads = for (i <- 0 until W) yield new Remover(ct, i, W, sz)
       
@@ -156,7 +156,7 @@ object SnapshotSpec extends Spec {
       val W = 10
       val S = 7000
       
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       val threads = for (i <- 0 until W) yield new Modifier(ct, i, N, sz)
       
@@ -165,7 +165,7 @@ object SnapshotSpec extends Spec {
       threads.foreach(_.join())
     }
     
-    def consistentNonReadOnly(name: String, trie: Ctrie[Wrap, Int], sz: Int, N: Int) {
+    def consistentNonReadOnly(name: String, trie: ConcurrentTrieMap[Wrap, Int], sz: Int, N: Int) {
       @volatile var e: Exception = null
       
       // reads possible entries once and stores them
@@ -223,7 +223,7 @@ object SnapshotSpec extends Spec {
       val W = 10
       val S = 400
       
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       val threads = for (i <- 0 until W) yield new Modifier(ct, i, N, sz)
       
@@ -241,7 +241,7 @@ object SnapshotSpec extends Spec {
       val S = 10
       val modifytimes = 1200
       val snaptimes = 600
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       for (i <- 0 until sz) ct(new Wrap(i)) = i
       
       class Snapshooter extends Thread {
diff --git a/test/files/run/existentials-in-compiler.scala b/test/files/run/existentials-in-compiler.scala
index e4f6920145..8c04e4782c 100644
--- a/test/files/run/existentials-in-compiler.scala
+++ b/test/files/run/existentials-in-compiler.scala
@@ -6,7 +6,7 @@ object Test extends CompilerTest {
   import global._
   import definitions._
 
-  def code = """
+  override def code = """
 package extest {
   trait Bippy[A <: AnyRef, B] { }     // wildcards
   trait BippyLike[A <: AnyRef, B <: List[A], This <: BippyLike[A, B, This] with Bippy[A, B]]  // no wildcards
diff --git a/test/files/run/matchonseq.check b/test/files/run/matchonseq.check
new file mode 100644
index 0000000000..3fe554095a
--- /dev/null
+++ b/test/files/run/matchonseq.check
@@ -0,0 +1,2 @@
+It worked! head=1
+It worked! last=3
diff --git a/test/files/run/matchonseq.scala b/test/files/run/matchonseq.scala
new file mode 100644
index 0000000000..49b406a6ec
--- /dev/null
+++ b/test/files/run/matchonseq.scala
@@ -0,0 +1,8 @@
+object Test extends App{
+  Vector(1,2,3) match { 
+   case head +: tail => println("It worked! head=" + head) 
+  }
+  Vector(1,2,3) match { 
+   case init :+ last => println("It worked! last=" + last) 
+  }
+}
diff --git a/test/files/run/t0663.check b/test/files/run/t0663.check
index 22b68b7f57..dd9be2af70 100644..100755
--- a/test/files/run/t0663.check
+++ b/test/files/run/t0663.check
@@ -1 +1 @@
-<feed></feed>
+<feed/>
diff --git a/test/files/run/t1620.check b/test/files/run/t1620.check
index 979efc8227..afa1e6acd5 100644..100755
--- a/test/files/run/t1620.check
+++ b/test/files/run/t1620.check
@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE foo PUBLIC "-//Foo Corp//DTD 1.0//EN" "foo.dtd">
-<foo></foo>
+<foo/>
 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE foo PUBLIC "-//Foo Corp//DTD 1.0//EN">
-<foo></foo>
+<foo/>
diff --git a/test/files/run/t2124.check b/test/files/run/t2124.check
index 2b8840209f..51b40469aa 100644..100755
--- a/test/files/run/t2124.check
+++ b/test/files/run/t2124.check
@@ -1 +1 @@
-<p><lost></lost><q></q></p>
+<p><lost/><q/></p>
diff --git a/test/files/run/t2125.check b/test/files/run/t2125.check
index 2b8840209f..51b40469aa 100644..100755
--- a/test/files/run/t2125.check
+++ b/test/files/run/t2125.check
@@ -1 +1 @@
-<p><lost></lost><q></q></p>
+<p><lost/><q/></p>
diff --git a/test/files/run/xml-attribute.check b/test/files/run/xml-attribute.check
index 3ae2034684..3cfe3779fc 100644
--- a/test/files/run/xml-attribute.check
+++ b/test/files/run/xml-attribute.check
@@ -1,12 +1,12 @@
-<t></t>
-<t></t>
-<t></t>
-<t></t>
-<t></t>
-<t b="1" d="2"></t>
-<t b="1" d="2"></t>
-<t b="1" d="2"></t>
-<t a="1" d="2"></t>
-<t b="1" d="2"></t>
-<t a="1" b="2" c="3"></t>
-<t g="1" e="2" p:a="3" f:e="4" mgruhu:ji="5"></t>
\ No newline at end of file
+<t/>
+<t/>
+<t/>
+<t/>
+<t/>
+<t b="1" d="2"/>
+<t b="1" d="2"/>
+<t b="1" d="2"/>
+<t a="1" d="2"/>
+<t b="1" d="2"/>
+<t a="1" b="2" c="3"/>
+<t g="1" e="2" p:a="3" f:e="4" mgruhu:ji="5"/>
diff --git a/test/files/scalacheck/Ctrie.scala b/test/files/scalacheck/Ctrie.scala
index 2950937278..b9d71b88a3 100644
--- a/test/files/scalacheck/Ctrie.scala
+++ b/test/files/scalacheck/Ctrie.scala
@@ -5,7 +5,7 @@ import org.scalacheck._
 import Prop._
 import org.scalacheck.Gen._
 import collection._
-import collection.mutable.Ctrie
+import collection.mutable.ConcurrentTrieMap
 
 
 
@@ -16,7 +16,7 @@ case class Wrap(i: Int) {
 
 /** A check mainly oriented towards checking snapshot correctness.
  */
-object Test extends Properties("Ctrie") {
+object Test extends Properties("ConcurrentTrieMap") {
   
   /* generators */
   
@@ -102,7 +102,7 @@ object Test extends Properties("Ctrie") {
     (numThreads, numElems) =>
     val p = 3 //numThreads
     val sz = 102 //numElems
-    val ct = new Ctrie[Wrap, Int]
+    val ct = new ConcurrentTrieMap[Wrap, Int]
     
     // checker
     val checker = spawn {
@@ -134,7 +134,7 @@ object Test extends Properties("Ctrie") {
   
   property("update") = forAll(sizes) {
     (n: Int) =>
-    val ct = new Ctrie[Int, Int]
+    val ct = new ConcurrentTrieMap[Int, Int]
     for (i <- 0 until n) ct(i) = i
     (0 until n) forall {
       case i => ct(i) == i
@@ -143,7 +143,7 @@ object Test extends Properties("Ctrie") {
   
   property("concurrent update") = forAll(threadCountsAndSizes) {
     case (p, sz) =>
-      val ct = new Ctrie[Wrap, Int]
+      val ct = new ConcurrentTrieMap[Wrap, Int]
       
       inParallel(p) {
         idx =>
@@ -158,7 +158,7 @@ object Test extends Properties("Ctrie") {
   
   property("concurrent remove") = forAll(threadCounts, sizes) {
     (p, sz) =>
-    val ct = new Ctrie[Wrap, Int]
+    val ct = new ConcurrentTrieMap[Wrap, Int]
     for (i <- 0 until sz) ct(Wrap(i)) = i
     
     inParallel(p) {
@@ -174,7 +174,7 @@ object Test extends Properties("Ctrie") {
   
   property("concurrent putIfAbsent") = forAll(threadCounts, sizes) {
     (p, sz) =>
-    val ct = new Ctrie[Wrap, Int]
+    val ct = new ConcurrentTrieMap[Wrap, Int]
     
     val results = inParallel(p) {
       idx =>
diff --git a/test/files/scalacheck/parallel-collections/ParallelCtrieCheck.scala b/test/files/scalacheck/parallel-collections/ParallelCtrieCheck.scala
index d1924f0ada..a04c0ff8d4 100644
--- a/test/files/scalacheck/parallel-collections/ParallelCtrieCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelCtrieCheck.scala
@@ -15,25 +15,25 @@ import scala.collection.parallel.ops._
 
 
 
-abstract class ParallelCtrieCheck[K, V](tp: String) extends ParallelMapCheck[K, V]("mutable.ParCtrie[" + tp + "]") {
+abstract class ParallelConcurrentTrieMapCheck[K, V](tp: String) extends ParallelMapCheck[K, V]("mutable.ParConcurrentTrieMap[" + tp + "]") {
   // ForkJoinTasks.defaultForkJoinPool.setMaximumPoolSize(Runtime.getRuntime.availableProcessors * 2)
   // ForkJoinTasks.defaultForkJoinPool.setParallelism(Runtime.getRuntime.availableProcessors * 2)
   
-  type CollType = ParCtrie[K, V]
+  type CollType = ParConcurrentTrieMap[K, V]
   
   def isCheckingViews = false
   
   def hasStrictOrder = false
 
   def ofSize(vals: Seq[Gen[(K, V)]], sz: Int) = {  
-    val ct = new mutable.Ctrie[K, V]
+    val ct = new mutable.ConcurrentTrieMap[K, V]
     val gen = vals(rnd.nextInt(vals.size))
     for (i <- 0 until sz) ct += sample(gen)
     ct
   }
   
   def fromTraversable(t: Traversable[(K, V)]) = {
-    val pct = new ParCtrie[K, V]
+    val pct = new ParConcurrentTrieMap[K, V]
     var i = 0
     for (kv <- t.toList) {
       pct += kv
@@ -45,7 +45,7 @@ abstract class ParallelCtrieCheck[K, V](tp: String) extends ParallelMapCheck[K,
 }
 
 
-object IntIntParallelCtrieCheck extends ParallelCtrieCheck[Int, Int]("Int, Int")
+object IntIntParallelConcurrentTrieMapCheck extends ParallelConcurrentTrieMapCheck[Int, Int]("Int, Int")
 with PairOperators[Int, Int]
 with PairValues[Int, Int]
 {
@@ -58,7 +58,7 @@ with PairValues[Int, Int]
   def koperators = intoperators
   
   override def printDataStructureDebugInfo(ds: AnyRef) = ds match {
-    case pm: ParCtrie[k, v] =>
+    case pm: ParConcurrentTrieMap[k, v] =>
       println("Mutable parallel ctrie")
     case _ =>
       println("could not match data structure type: " + ds.getClass)
diff --git a/test/files/scalacheck/parallel-collections/pc.scala b/test/files/scalacheck/parallel-collections/pc.scala
index 8a0dba3c25..0a91977da0 100644
--- a/test/files/scalacheck/parallel-collections/pc.scala
+++ b/test/files/scalacheck/parallel-collections/pc.scala
@@ -26,7 +26,7 @@ class ParCollProperties extends Properties("Parallel collections") {
   include(mutable.IntIntParallelHashMapCheck)
   
   // parallel ctrie
-  include(mutable.IntIntParallelCtrieCheck)
+  include(mutable.IntIntParallelConcurrentTrieMapCheck)
   
   // parallel mutable hash sets (tables)
   include(mutable.IntParallelHashSetCheck)
diff --git a/test/scaladoc/resources/explicit-inheritance-override.scala b/test/scaladoc/resources/explicit-inheritance-override.scala
new file mode 100644
index 0000000000..62ce653aea
--- /dev/null
+++ b/test/scaladoc/resources/explicit-inheritance-override.scala
@@ -0,0 +1,48 @@
+// This tests the implicit comment inheritance capabilities of scaladoc for class inheritance (no $super, no @inheritdoc)
+class InheritDocBase {
+  /**
+   * The base comment. And another sentence...
+   *
+   * @param  arg1 The T term comment
+   * @param  arg2 The string comment
+   * @tparam T the type of the first argument
+   * @throws SomeException if the function is not called with correct parameters
+   * @return The return comment
+   * @see The Manual
+   * @note Be careful!
+   * @example function[Int](3, "something")
+   * @author a Scala developer
+   * @version 0.0.2
+   * @since 0.0.1
+   * @todo Call mom.
+   */
+  def function[T](arg1: T, arg2: String): Double = 0.0d
+}
+
+class InheritDocDerived extends InheritDocBase {
+  /**
+   * Starting line
+   *
+   * @inheritdoc
+   * @inheritdoc
+   *
+   * Ending line
+   *
+   * @param arg1 Start1 @inheritdoc End1
+   * @param arg2 Start2 @inheritdoc End2
+   * @param arg3 Start3 ShouldWarn @inheritdoc End3
+   * @tparam T StartT @inheritdoc EndT
+   * @tparam ShouldWarn StartSW @inheritdoc EndSW
+   * @throws SomeException StartEx @inheritdoc EndEx
+   * @throws SomeOtherException StartSOE Should Warn @inheritdoc EndSOE
+   * @return StartRet @inheritdoc EndRet
+   * @see StartSee @inheritdoc EndSee
+   * @note StartNote @inheritdoc EndNote
+   * @example StartExample @inheritdoc EndExample
+   * @author StartAuthor @inheritdoc EndAuthor
+   * @version StartVer @inheritdoc EndVer
+   * @since StartSince @inheritdoc EndSince
+   * @todo StartTodo @inheritdoc And dad! EndTodo
+   */
+  override def function[T](arg1: T, arg2: String): Double = 1.0d
+}
\ No newline at end of file
diff --git a/test/scaladoc/resources/explicit-inheritance-usecase.scala b/test/scaladoc/resources/explicit-inheritance-usecase.scala
new file mode 100644
index 0000000000..e10cec437a
--- /dev/null
+++ b/test/scaladoc/resources/explicit-inheritance-usecase.scala
@@ -0,0 +1,47 @@
+// This tests the implicit comment inheritance capabilities of scaladoc for usecases (no $super, no @inheritdoc)
+/** Testing use case inheritance */
+class UseCaseInheritDoc {
+  /**
+   * The base comment. And another sentence...
+   *
+   * @param  arg1 The T term comment
+   * @param  arg2 The string comment
+   * @tparam T the type of the first argument
+   * @throws SomeException if the function is not called with correct parameters
+   * @return The return comment
+   * @see The Manual
+   * @note Be careful!
+   * @example function[Int](3, "something")
+   * @author a Scala developer
+   * @version 0.0.2
+   * @since 0.0.1
+   * @todo Call mom.
+   *
+   * @usecase def function[T](arg1: T, arg2: String): Double
+   *
+   * Starting line
+   *
+   * @inheritdoc
+   * @inheritdoc
+   *
+   * Ending line
+   *
+   * @param arg1 Start1 @inheritdoc End1
+   * @param arg2 Start2 @inheritdoc End2
+   * @param arg3 Start3 ShouldWarn @inheritdoc End3
+   * @tparam T StartT @inheritdoc EndT
+   * @tparam ShouldWarn StartSW @inheritdoc EndSW
+   * @throws SomeException StartEx @inheritdoc EndEx
+   * @throws SomeOtherException StartSOE Should Warn @inheritdoc EndSOE
+   * @return StartRet @inheritdoc EndRet
+   * @see StartSee @inheritdoc EndSee
+   * @note StartNote @inheritdoc EndNote
+   * @example StartExample @inheritdoc EndExample
+   * @author StartAuthor @inheritdoc EndAuthor
+   * @version StartVer @inheritdoc EndVer
+   * @since StartSince @inheritdoc EndSince
+   * @todo StartTodo @inheritdoc And dad! EndTodo
+   */
+  def function[T](implicit arg1: T, arg2: String): Double = 0.0d
+}
+
diff --git a/test/scaladoc/resources/implicit-inheritance-override.scala b/test/scaladoc/resources/implicit-inheritance-override.scala
index 85b8e8d543..5d692f59ad 100644
--- a/test/scaladoc/resources/implicit-inheritance-override.scala
+++ b/test/scaladoc/resources/implicit-inheritance-override.scala
@@ -2,12 +2,12 @@
 class Base {
   /**
    * The base comment. And another sentence...
-   * 
-   * @param arg1 The T term comment
-   * @param arg2 The string comment
+   *
+   * @param  arg1 The T term comment
+   * @param  arg2 The string comment
    * @tparam T the type of the first argument
    * @return The return comment
-   */ 
+   */
   def function[T](arg1: T, arg2: String): Double = 0.0d
 }
 
diff --git a/test/scaladoc/resources/inheritdoc-corner-cases.scala b/test/scaladoc/resources/inheritdoc-corner-cases.scala
new file mode 100644
index 0000000000..8cd995e605
--- /dev/null
+++ b/test/scaladoc/resources/inheritdoc-corner-cases.scala
@@ -0,0 +1,78 @@
+// TEST1: Inherit from multiple classes
+trait A {
+  /**
+   * Hello 1 comment
+   */
+  def hello1 = 0
+}
+
+trait B {
+  /**
+   * Hello 2 comment
+   */
+  def hello2 = 1
+}
+
+trait C extends B
+
+class D extends A with C {
+  /**
+   * Inherited: @inheritdoc
+   */
+  override def hello1 = super.hello2
+
+  /**
+   * Inherited: @inheritdoc
+   */
+  override def hello2 = super.hello1
+}
+
+// TEST2: Invalid inherit: no parents
+trait E {
+  /**
+   * @inheritdoc
+   */
+  def whereDidThisComeFrom
+}
+
+// TEST3: Invalid inherit, but other parents present
+trait F extends E {
+  /**
+   * @inheritdoc
+   */
+  def howAboutThis
+}
+
+
+// TEST4: Inherit from something that inherits: inherit should propagate
+trait G extends D {
+  /**
+   * @inheritdoc
+   */
+  override def hello1 = 13
+
+  /**
+   * @inheritdoc
+   */
+  override def hello2 = 14
+}
+
+// TEST5: Inherit missing parameters
+trait H extends G {
+  /**
+   * Missing params
+   * @throws HelloException @inheritdoc
+   * @todo @inheritdoc
+   */
+  override def hello1 = 15
+}
+
+// TEST6: Inherit from something that inherits in the usecase
+trait I extends G {
+  /**
+   * @inheritdoc
+   * @usecase def hello1(i: Int)
+   *   @inheritdoc
+   */
+  override def hello1 = 13
+}
\ No newline at end of file
diff --git a/test/scaladoc/scala/html/HtmlFactoryTest.scala b/test/scaladoc/scala/html/HtmlFactoryTest.scala
index d46a9581b9..67358e6e70 100644
--- a/test/scaladoc/scala/html/HtmlFactoryTest.scala
+++ b/test/scaladoc/scala/html/HtmlFactoryTest.scala
@@ -21,9 +21,9 @@ object XMLUtil {
 }
 
 object Test extends Properties("HtmlFactory") {
-	
-	final val RESOURCES = "test/scaladoc/resources/"
-	
+
+  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
@@ -87,7 +87,7 @@ object Test extends Properties("HtmlFactory") {
 
   /**
    * This tests the text without the markup - ex:
-   * 
+   *
    * <h4 class="signature">
    *  <span class="modifier_kind">
    *    <span class="modifier">implicit</span>
@@ -97,24 +97,24 @@ object Test extends Properties("HtmlFactory") {
    *    <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, debug: Boolean = true)(checks: (Option[String], String, Boolean)*): Boolean = {
-    val htmlFile = scalaFile.stripSuffix(".scala") + ".html"    
+    val htmlFile = scalaFile.stripSuffix(".scala") + ".html"
     val htmlAllFiles = createTemplates(scalaFile)
     var result = true
-    
+
     for ((fileHint, check, expected) <- checks) {
       // resolve the file to be checked
       val fileName = fileHint match {
-        case Some(file) => 
+        case Some(file) =>
           if (file endsWith ".html")
             file
           else
@@ -122,20 +122,27 @@ object Test extends Properties("HtmlFactory") {
         case None =>
           htmlFile
       }
-      val fileText = htmlAllFiles(fileName).text.replace('→',' ').replaceAll("\\s+","")
-      val checkText = check.replace('→',' ').replaceAll("\\s+","")
+      val fileTextPretty = htmlAllFiles(fileName).text.replace('→',' ').replaceAll("\\s+"," ")
+      val fileText = fileTextPretty.replaceAll(" ", "")
+
+      val checkTextPretty = check.replace('→',' ').replaceAll("\\s+"," ")
+      val checkText = checkTextPretty.replaceAll(" ", "")
+
       val checkValue = fileText.contains(checkText) == expected
       if (debug && (!checkValue)) {
-        Console.err.println("Check failed: ")
-        Console.err.println("HTML: " + fileText)
-        Console.err.println("Check: " + checkText)
+        Console.err.println("")
+        Console.err.println("HTML Check failed for resource file " + scalaFile + ":")
+        Console.err.println("Could not match: \n" + checkTextPretty)
+        Console.err.println("In the extracted HTML text: \n" + fileTextPretty)
+        Console.err.println("NOTE: The whitespaces are eliminated before matching!")
+        Console.err.println("")
       }
-      result &&= checkValue 
+      result &&= checkValue
     }
-    
+
     result
   }
-  
+
 
   def shortComments(root: scala.xml.Node) =
     XMLUtil.stripGroup(root).descendant.flatMap {
@@ -284,7 +291,7 @@ object Test extends Properties("HtmlFactory") {
       case _ => false
     }
   }
-  
+
   property("Trac #4420 - no whitespace at end of line") = {
     val files = createTemplates("Trac4420.scala")
 
@@ -432,47 +439,46 @@ object Test extends Properties("HtmlFactory") {
     createTemplate("SI_4898.scala")
     true
   }
- 
+
   property("Use cases should override their original members") =
      checkText("SI_5054_q1.scala")(
        (None,"""def test(): Int""", true),
        (None,"""def test(implicit lost: Int): Int""", false)
      )
 
-  property("Use cases should keep their flags - final should not be lost") = 
+  property("Use cases should keep their flags - final should not be lost") =
     checkText("SI_5054_q2.scala")((None, """final def test(): Int""", true))
-  
-  property("Use cases should keep their flags - implicit should not be lost") = 
+
+  property("Use cases should keep their flags - implicit should not be lost") =
     checkText("SI_5054_q3.scala")((None, """implicit def test(): Int""", true))
- 
-  property("Use cases should keep their flags - real abstract should not be lost") = 
+
+  property("Use cases should keep their flags - real abstract should not be lost") =
     checkText("SI_5054_q4.scala")((None, """abstract def test(): Int""", true))
 
-  property("Use cases should keep their flags - traits should not be affected") = 
+  property("Use cases should keep their flags - traits should not be affected") =
     checkText("SI_5054_q5.scala")((None, """def test(): Int""", true))
 
-  property("Use cases should keep their flags - traits should not be affected") = 
+  property("Use cases should keep their flags - traits should not be affected") =
     checkText("SI_5054_q6.scala")((None, """abstract def test(): Int""", true))
-   
-  property("Use case individual signature test") = 
+
+  property("Use case individual signature test") =
     checkText("SI_5054_q7.scala")(
       (None, """abstract def test2(explicit: Int): Int [use case] This takes the explicit value passed.""", true),
       (None, """abstract def test1(): Int [use case] This takes the implicit value in scope.""", true)
     )
 
-  property("Display correct \"Definition classes\"") = 
-    checkText("SI_5287.scala")( 
+  property("Display correct \"Definition classes\"") =
+    checkText("SI_5287.scala")(
       (None,
           """def method(): Int
            [use case] The usecase explanation
            [use case] The usecase explanation
            Definition Classes SI_5287 SI_5287_B SI_5287_A""", true)
-    )      // the explanation appears twice, as small comment and full comment           
-  
-    
-  property("Correct comment inheritance for overriding") = 
+    )      // the explanation appears twice, as small comment and full comment
+
+  property("Correct comment inheritance for overriding") =
     checkText("implicit-inheritance-override.scala")(
-      (Some("Base"), 
+      (Some("Base"),
        """def function[T](arg1: T, arg2: String): Double
           The base comment.
           The base comment. And another sentence...
@@ -481,7 +487,7 @@ object Test extends Properties("HtmlFactory") {
           arg2 The string comment
           returns The return comment
           """, true),
-      (Some("DerivedA"), 
+      (Some("DerivedA"),
        """def function[T](arg1: T, arg2: String): Double
           Overriding the comment, the params and returns comments should stay the same.
           Overriding the comment, the params and returns comments should stay the same.
@@ -490,21 +496,21 @@ object Test extends Properties("HtmlFactory") {
           arg2 The string comment
           returns The return comment
           """, true),
-      (Some("DerivedB"), 
+      (Some("DerivedB"),
        """def function[T](arg1: T, arg2: String): Double
           T the type of the first argument
           arg1 The overridden T term comment
           arg2 The overridden string comment
           returns The return comment
           """, true),
-      (Some("DerivedC"), 
+      (Some("DerivedC"),
        """def function[T](arg1: T, arg2: String): Double
           T the type of the first argument
           arg1 The T term comment
           arg2 The string comment
           returns The overridden return comment
           """, true),
-      (Some("DerivedD"), 
+      (Some("DerivedD"),
        """def function[T](arg1: T, arg2: String): Double
           T The overriden type parameter comment
           arg1 The T term comment
@@ -512,11 +518,11 @@ object Test extends Properties("HtmlFactory") {
           returns The return comment
           """, true)
     )
-    
+
   for (useCaseFile <- List("UseCaseInheritance", "UseCaseOverrideInheritance")) {
-    property("Correct comment inheritance for usecases") = 
+    property("Correct comment inheritance for usecases") =
       checkText("implicit-inheritance-usecase.scala")(
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def missing_arg[T](arg1: T): Double
             [use case]
             [use case]
@@ -524,7 +530,7 @@ object Test extends Properties("HtmlFactory") {
             arg1 The T term comment
             returns The return comment
             """, true),
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def missing_targ(arg1: Int, arg2: String): Double
             [use case]
             [use case]
@@ -532,7 +538,7 @@ object Test extends Properties("HtmlFactory") {
             arg2 The string comment
             returns The return comment
             """, true),
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def overridden_arg1[T](implicit arg1: T, arg2: String): Double
             [use case]
             [use case]
@@ -541,7 +547,7 @@ object Test extends Properties("HtmlFactory") {
             arg2 The string comment
             returns The return comment
             """, true),
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def overridden_targ[T](implicit arg1: T, arg2: String): Double
             [use case]
             [use case]
@@ -550,7 +556,7 @@ object Test extends Properties("HtmlFactory") {
             arg2 The string comment
             returns The return comment
             """, true),
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def overridden_return[T](implicit arg1: T, arg2: String): Double
             [use case]
             [use case]
@@ -559,7 +565,7 @@ object Test extends Properties("HtmlFactory") {
             arg2 The string comment
             returns The overridden return comment
             """, true),
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def added_arg[T](implicit arg1: T, arg2: String, arg3: Float): Double
             [use case]
             [use case]
@@ -569,7 +575,7 @@ object Test extends Properties("HtmlFactory") {
             arg3 The added float comment
             returns The return comment
             """, true),
-        (Some(useCaseFile), 
+        (Some(useCaseFile),
          """def overridden_comment[T](implicit arg1: T, arg2: String): Double
             [use case] The overridden comment.
             [use case] The overridden comment.
@@ -578,9 +584,93 @@ object Test extends Properties("HtmlFactory") {
             arg2 The string comment
             returns The return comment
             """, true)
-      )    
-  }
-    
+      )
+  }
+
+  property("Correct explicit inheritance for override") =
+  checkText("explicit-inheritance-override.scala")(
+    (Some("InheritDocDerived"),
+     """def function[T](arg1: T, arg2: String): Double
+        Starting line
+        Starting line
+        The base comment. And another sentence...
+        The base comment. And another sentence...
+        Ending line
+          T       StartT the type of the first argument EndT
+          arg1    Start1 The T term comment End1
+          arg2    Start2 The string comment End2
+          returns StartRet The return comment EndRet
+        Definition Classes InheritDocDerived → InheritDocBase
+        Example:   StartExample function[Int](3, "something") EndExample
+        Version    StartVer 0.0.2 EndVer
+        Since      StartSince 0.0.1 EndSince
+        Exceptions thrown
+                   SomeException      StartEx if the function is not called with correct parameters EndEx
+                   SomeOtherException StartSOE Should Warn <invalid inheritdoc annotation> EndSOE
+        To do      StartTodo Call mom. And dad! EndTodo
+        Note       StartNote Be careful! EndNote
+        See also   StartSee The Manual EndSee
+     """, true))
+
+  property("Correct explicit inheritance for usecase") =
+  checkText("explicit-inheritance-usecase.scala")(
+    (Some("UseCaseInheritDoc"),
+     """def function[T](arg1: T, arg2: String): Double
+        [use case] Starting line
+        [use case] Starting line
+        The base comment. And another sentence...
+        The base comment. And another sentence...
+        Ending line
+          T       StartT the type of the first argument EndT
+          arg1    Start1 The T term comment End1
+          arg2    Start2 The string comment End2
+          returns StartRet The return comment EndRet
+        Example:   StartExample function[Int](3,"something") EndExample
+        Version    StartVer 0.0.2 EndVer
+        Since      StartSince 0.0.1 EndSince
+        Exceptions thrown
+                   SomeException      StartEx if the function is not called with correct parameters EndEx
+                   SomeOtherException StartSOE Should Warn <invalid inheritdoc annotation> EndSOE
+        To do      StartTodo Call mom. And dad! EndTodo
+        Note       StartNote Be careful! EndNote
+        See also   StartSee The Manual EndSee
+     """, true))
+
+  property("Correct explicit inheritance in corner cases") =
+    checkText("inheritdoc-corner-cases.scala")(
+      (Some("D"),
+       """def hello1: Int
+          Inherited: Hello 1 comment
+          Inherited: Hello 1 comment
+          Definition Classes D → A
+       """, true),
+      (Some("D"),
+       """def hello2: Int
+          Inherited: Hello 2 comment
+          Inherited: Hello 2 comment
+          Definition Classes D → B
+       """, true),
+      (Some("G"),
+       """def hello1: Int
+          Inherited: Hello 1 comment
+          Inherited: Hello 1 comment
+          Definition Classes G → D → A
+       """, true),
+      (Some("G"),
+       """def hello2: Int
+          Inherited: Hello 2 comment
+          Inherited: Hello 2 comment
+          Definition Classes G → D → B
+       """, true),
+      (Some("I"),
+       """def hello1(i: Int): Unit
+          [use case] Inherited: Hello 1 comment
+          [use case] Inherited: Hello 1 comment
+          Definition Classes I → G → D → A
+       """, true)
+      // traits E, F and H shouldn't crash scaladoc but we don't need to check the output
+    )
+
   {
     val files = createTemplates("basic.scala")
     //println(files)