Even hackier fix

This one follows the current logic more closely, instead of assuming we can
compute the kind of a type. I think this is even more fragile, but I should show
that; for instance, I should try to create an example which needs *two*
`asSeenFrom` calls to give the correct behavior.

Author: Blaisorblade

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

@@ -198,6 +198,40 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
   }
 
+  // Argh, we'll need in fact multiple substitutions.
+  final def typeParamsAndPrefix(maybePrefix: Type)(implicit ctx: Context): (List[TypeParamInfo], Type) = /*>|>*/ track("typeParams") /*<|<*/ {
+    try self match {
+      case self: TypeRef =>
+        val tsym = self.symbol
+        if (tsym.isClass) (tsym.typeParams, self.prefix)
+        else if (!tsym.exists) self.info.typeParamsAndPrefix(self.prefix)
+        else tsym.infoOrCompleter match {
+          case info: LazyType =>
+            (info.completerTypeParams(tsym), self.prefix) //XXX
+          case info => info.typeParamsAndPrefix(self.prefix)
+        }
+      case self: AppliedType =>
+        if (self.tycon.typeSymbol.isClass)
+          (Nil, maybePrefix)
+        else self.superType.typeParamsAndPrefix(maybePrefix)
+      case self: ClassInfo =>
+        (self.cls.typeParams, self)
+      case self: HKTypeLambda =>
+        (self.typeParams, maybePrefix)
+      case _: SingletonType | _: RefinedType | _: RecType =>
+        (Nil, maybePrefix)
+      case self: WildcardType =>
+        self.optBounds.typeParamsAndPrefix(maybePrefix)
+      case self: TypeProxy =>
+        self.superType.typeParamsAndPrefix(maybePrefix)
+      case _ =>
+        (Nil, maybePrefix)
+    }
+    catch {
+      case ex: Throwable => handleRecursive("type parameters and prefix of", self.show, ex)
+    }
+  }
+
   /** If `self` is a higher-kinded type, its type parameters, otherwise Nil */
   final def hkTypeParams(implicit ctx: Context): List[TypeParamInfo] =
     if (isLambdaSub) typeParams else Nil

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -74,13 +74,13 @@ object Checking {
     val AppliedTypeTree(tycon, args) = tree
     // If `args` is a list of named arguments, return corresponding type parameters,
     // otherwise return type parameters unchanged
-    val tparams = kind(tycon.tpe).typeParams
+    val (tparams, prefix) = tycon.tpe.typeParamsAndPrefix(tree.tpe)
     def argNamed(tparam: ParamInfo) = args.find {
       case NamedArg(name, _) => name == tparam.paramName
       case _ => false
     }.getOrElse(TypeTree(tparam.paramRef))
     val orderedArgs = if (hasNamedArg(args)) tparams.map(argNamed) else args
-    val bounds = tparams.map(_.paramInfoAsSeenFrom(tree.tpe).bounds)
+    val bounds = tparams.map(_.paramInfoAsSeenFrom(prefix.widen).bounds)
     def instantiate(bound: Type, args: List[Type]) =
       HKTypeLambda.fromParams(tparams, bound).appliedTo(args)
     if (boundsCheck) checkBounds(orderedArgs, bounds, instantiate)