Fix #3343: Make baseType work properly with type lambdas

Previously,
    `C[Char]`.baseType(`Traversable[Char]`)
    where C := `[X] => List|X]`
returned `Traversable[ParamRef(A)]` instead of `Traversable[Char]`,
because the substitution was done on the type parameters of the class
symbol instead of the type parameters of the type, these are different
when type lambdas are involved.

Author: smarter

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1648,9 +1648,7 @@ object SymDenotations {
             if (subsym eq symbol) tp
             else subsym.denot match {
               case clsd: ClassDenotation =>
-                val tparams = clsd.typeParams
-                if (tparams.hasSameLengthAs(args)) baseTypeOf(tycon).subst(tparams, args)
-                else NoType
+                baseTypeOf(tycon).substTypeParams(tycon, args)
               case _ =>
                 baseTypeOf(tp.superType)
             }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1307,6 +1307,12 @@ object Types {
     final def substParams(from: BindingType, to: List[Type])(implicit ctx: Context): Type =
       ctx.substParams(this, from, to, null)
 
+    /** Substitute the type parameters of `from` by some other types */
+    final def substTypeParams(from: Type, to: List[Type])(implicit ctx: Context): Type = from.typeParams match {
+      case LambdaParam(lam, _) :: _ => this.substParams(lam, to)
+      case tparams: List[Symbol @unchecked] => this.subst(tparams, to)
+    }
+
     /** Substitute all occurrences of symbols in `from` by references to corresponding symbols in `to`
      */
     final def substSym(from: List[Symbol], to: List[Symbol])(implicit ctx: Context): Type =

tests/pos/i3343.scala

@@ -0,0 +1,5 @@
+object Test {
+  def foo[C[_]](implicit t: C[Char] => Traversable[Char]): C[Char] = ???
+
+  val a: List[Char] = foo
+}