Drop argumnt interpolation.

It turns out it's not needed because now all type arguments are
expressed as aliases. Interestingly dropping this feature shaved
20% off the time off junit tests. Which seems to indicate that the
handling of type application is really performance critical.

Author: odersky

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

@@ -286,7 +286,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    */
   final def baseArgInfos(base: Symbol)(implicit ctx: Context): List[Type] =
     if (self derivesFrom base)
-      base.typeParams map (param => self.member(param.name).info.argInfo(param))
+      base.typeParams map (param => self.member(param.name).info.argInfo)
     else
       Nil
 
@@ -311,7 +311,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** The first type argument of the base type instance wrt `base` of this type */
   final def firstBaseArgInfo(base: Symbol)(implicit ctx: Context): Type = base.typeParams match {
     case param :: _ if self derivesFrom base =>
-      self.member(param.name).info.argInfo(param)
+      self.member(param.name).info.argInfo
     case _ =>
       NoType
   }
@@ -371,7 +371,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  Existential types in arguments are returned as TypeBounds instances.
    *  @param interpolate   See argInfo
    */
-  final def argInfos(interpolate: Boolean)(implicit ctx: Context): List[Type] = {
+  final def argInfos(implicit ctx: Context): List[Type] = {
     var tparams: List[TypeSymbol] = null
     def recur(tp: Type, refineCount: Int): mutable.ListBuffer[Type] = tp.stripTypeVar match {
       case tp @ RefinedType(tycon, name) =>
@@ -381,7 +381,7 @@ class TypeApplications(val self: Type) extends AnyVal {
           if (tparams == null) tparams = tycon.typeParams
           if (buf.size < tparams.length) {
             val tparam = tparams(buf.size)
-            if (name == tparam.name) buf += tp.refinedInfo.argInfo(tparam, interpolate)
+            if (name == tparam.name) buf += tp.refinedInfo.argInfo
             else null
           } else null
         }
@@ -393,8 +393,6 @@ class TypeApplications(val self: Type) extends AnyVal {
     if (buf == null) Nil else buf.toList
   }
 
-  final def argInfos(implicit ctx: Context): List[Type] = argInfos(interpolate = true)
-
   /** Argument types where existential types in arguments are disallowed */
   def argTypes(implicit ctx: Context) = argInfos mapConserve noBounds
 
@@ -428,18 +426,10 @@ class TypeApplications(val self: Type) extends AnyVal {
    *
    *                       for a contravariant type-parameter becomes L.
    */
-  final def argInfo(tparam: Symbol, interpolate: Boolean = true)(implicit ctx: Context): Type = self match {
+  final def argInfo(implicit ctx: Context): Type = self match {
     case self: TypeAlias => self.alias
-    case TypeBounds(lo, hi) =>
-      if (interpolate) {
-        val v = tparam.variance
-        if (v > 0 && (lo isRef defn.NothingClass)) hi
-        else if (v < 0 && (hi isRef defn.AnyClass)) lo
-        else self
-      }
-      else self
-    case _ =>
-      NoType
+    case self: TypeBounds => self
+    case _ => NoType
   }
 
   /** The element type of a sequence or array */

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -140,14 +140,14 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
 
   private def firstTry(tp1: Type, tp2: Type): Boolean = tp2 match {
     case tp2: NamedType =>
-      def compareNamed = {
+      def compareNamed(tp1: Type, tp2: NamedType): Boolean = {
         implicit val ctx: Context = this.ctx
         tp2.info match {
           case info2: TypeAlias => firstTry(tp1, info2.alias)
           case _ => tp1 match {
             case tp1: NamedType =>
               tp1.info match {
-                case info1: TypeAlias => firstTry(info1.alias, tp2)
+                case info1: TypeAlias => compareNamed(info1.alias, tp2)
                 case _ =>
                   val sym1 = tp1.symbol
                   (if ((sym1 ne NoSymbol) && (sym1 eq tp2.symbol))
@@ -171,7 +171,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           }
         }
       }
-      compareNamed
+      compareNamed(tp1, tp2)
     case tp2: ProtoType =>
       isMatchedByProto(tp2, tp1)
     case tp2: BoundType =>

src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -211,7 +211,7 @@ class TreePickler(pickler: TastyPickler) {
       case tpe: SkolemType =>
         pickleType(tpe.info)
       case tpe: RefinedType =>
-        val args = tpe.argInfos(interpolate = false)
+        val args = tpe.argInfos
         if (args.isEmpty) {
           writeByte(REFINEDtype)
           withLength {

src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -109,7 +109,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       }
     homogenize(tp) match {
       case tp: RefinedType =>
-        val args = tp.argInfos(interpolate = false)
+        val args = tp.argInfos
         if (args.nonEmpty) {
           val tycon = tp.unrefine
           val cls = tycon.typeSymbol

src/dotty/tools/dotc/typer/Namer.scala

@@ -848,7 +848,7 @@ class Namer { typer: Typer =>
     def apply(tp: Type): Type = {
       tp match {
         case tp: RefinedType =>
-          val args = tp.argInfos(interpolate = false).mapconserve(this)
+          val args = tp.argInfos.mapconserve(this)
           if (args.nonEmpty) {
             val tycon = tp.withoutArgs(args)
             val tparams = tycon.typeParams