Fixed an issue with higher kinded type inference on constructors

without any help from adriaan.  Provisionally notched belt.
Wrapped up as many tickets as I added characters of code.
Closes SI-3343, SI-4018.  Review by moors.

git-svn-id: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk@25110 5e8d7ff9-d8ef-0310-90f0-a4852d11357a

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -3188,7 +3188,7 @@ trait Typers extends Modes {
           if (tpt0.hasSymbol && !tpt0.symbol.typeParams.isEmpty) {
             context.undetparams = cloneSymbols(tpt0.symbol.typeParams)
             TypeTree().setOriginal(tpt0)
-                      .setType(appliedType(tpt0.tpe, context.undetparams map (_.tpe)))
+                      .setType(appliedType(tpt0.tpe, context.undetparams map (_.tpeHK))) // @PP: tpeHK! #3343, #4018, #4347.
           } else tpt0
         }
 

test/files/pos/bug3343.scala

@@ -0,0 +1,15 @@
+import scala.collection.mutable.{ Builder, ListBuffer }
+
+object Test {
+  class Converter[T]
+  object SimpleIntConverter extends Converter[Int]
+
+  class TraversableConverter[T, Coll[X] <: Traversable[X]](converter: Converter[T], builder: Builder[T, Coll[T]]) extends Converter[Coll[T]] {
+    def convert(x: T): List[T] = List(x)
+  }
+  val tc: Converter[List[Int]] = new TraversableConverter(SimpleIntConverter, new ListBuffer[Int])
+  val tc2 = new TraversableConverter(SimpleIntConverter, new ListBuffer[Int])
+
+  def main(args: Array[String]): Unit = {
+  }
+}

test/files/pos/bug4018.scala

@@ -0,0 +1,15 @@
+trait M[V[_]]
+
+class Cls[V[_]](c: M[V])
+
+object Cls{
+  def apply[V[_]](c: M[V]): Cls[V] = new Cls[V](c)
+}
+
+object test {
+  val c: M[Option] = new M[Option] {}
+  new Cls(c)         // does not infer.
+  new Cls[Option](c) // okay
+  Cls(c)             // okay
+}
+

test/files/pos/hk-infer.scala

@@ -0,0 +1,34 @@
+object Basis {
+  final case class X[T](t: T)
+  val x  = Seq(X(32))
+  val y  = Seq(X(true))
+  val x1 = Seq(X("asdf"))
+  val x2 = Seq(X('d'))
+}
+import Basis._
+
+object DoesWork {
+  def f2 = List(x, y, x1, x2).flatten
+}
+
+// Testing the not giving of explicit Booper[M] arguments.
+object ShouldWorkHK {
+  class Booper[M[_]](xs: Seq[M[_]]) extends collection.generic.SeqForwarder[M[_]] {
+    def underlying = xs
+    def BOOP(ys: Seq[M[_]]) = new Booper(xs ++ ys)
+  }
+  implicit def mkBoop[M[_]](xs: Seq[M[_]]) = new Booper(xs)
+
+  def f1 = x BOOP y BOOP x1 BOOP x2
+}
+
+object DoesWorkHK {
+  class Booper[M[_]](xs: Seq[M[_]]) extends collection.generic.SeqForwarder[M[_]] {
+    def underlying = xs
+    def BOOP(ys: Seq[M[_]]) = new Booper[M](xs ++ ys)
+  }
+  implicit def mkBoop[M[_]](xs: Seq[M[_]]) = new Booper[M](xs)
+  
+  def f1 = x BOOP y BOOP x1 BOOP x2
+}
+