Drop AnyAppliedType

Author: odersky

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

@@ -64,48 +64,11 @@ object TypeApplications {
     }
 
     def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] = tp match {
-      case tp @ HKTypeLambda(tparams, AnyAppliedType(fn: TypeRef, args)) if (args == tparams.map(_.paramRef)) => Some(fn)
+      case tp @ HKTypeLambda(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.paramRef)) => Some(fn)
       case _ => None
     }
   }
 
-  /** Extractor for type application T[U_1, ..., U_n]. This is the refined type
-   *
-   *     T { type p_1 v_1= U_1; ...; type p_n v_n= U_n }
-   *
-   *  where v_i, p_i are the variances and names of the type parameters of T.
-   */
-  object AnyAppliedType { // @!!! drop
-    def apply(tp: Type, args: List[Type])(implicit ctx: Context): Type = tp.appliedTo(args)
-
-    def unapply(tp: Type)(implicit ctx: Context): Option[(Type, List[Type])] = tp match {
-      case tp: RefinedType =>
-        var refinements: List[RefinedType] = Nil
-        var tycon = tp.stripTypeVar
-        while (tycon.isInstanceOf[RefinedType]) {
-          val rt = tycon.asInstanceOf[RefinedType]
-          refinements = rt :: refinements
-          tycon = rt.parent.stripTypeVar
-        }
-        def collectArgs(tparams: List[TypeParamInfo],
-                        refinements: List[RefinedType],
-                        argBuf: mutable.ListBuffer[Type]): Option[(Type, List[Type])] = refinements match {
-          case Nil if tparams.isEmpty && argBuf.nonEmpty =>
-            Some((tycon, argBuf.toList))
-          case RefinedType(_, rname, rinfo) :: refinements1
-          if tparams.nonEmpty && rname == tparams.head.paramName =>
-            collectArgs(tparams.tail, refinements1, argBuf += rinfo.argInfo)
-          case _ =>
-            None
-        }
-        collectArgs(tycon.typeParams, refinements, new mutable.ListBuffer[Type])
-      case AppliedType(tycon, args) =>
-        Some((tycon, args))
-      case _ =>
-        None
-    }
-  }
-
    /** Adapt all arguments to possible higher-kinded type parameters using etaExpandIfHK
    */
   def EtaExpandIfHK(tparams: List[TypeParamInfo], args: List[Type])(implicit ctx: Context): List[Type] =
@@ -400,7 +363,7 @@ class TypeApplications(val self: Type) extends AnyVal {
           if (!args.exists(_.isInstanceOf[TypeBounds])) {
             val followAlias = Config.simplifyApplications && {
               dealiased.resType match {
-                case AnyAppliedType(tyconBody, dealiasedArgs) =>
+                case AppliedType(tyconBody, dealiasedArgs) =>
                   // Reduction should not affect type inference when it's
                   // just eta-reduction (ignoring variance annotations).
                   // See i2201*.scala for examples where more aggressive
@@ -413,7 +376,7 @@ class TypeApplications(val self: Type) extends AnyVal {
             else AppliedType(self, args)
           }
           else dealiased.resType match {
-            case AnyAppliedType(tycon, args1) if tycon.safeDealias ne tycon =>
+            case AppliedType(tycon, args1) if tycon.safeDealias ne tycon =>
               // In this case we should always dealias since we cannot handle
               // higher-kinded applications to wildcard arguments.
               dealiased
@@ -504,7 +467,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  Existential types in arguments are returned as TypeBounds instances.
    */
   final def argInfos(implicit ctx: Context): List[Type] = self match {
-    case AnyAppliedType(tycon, args) => args
+    case AppliedType(tycon, args) => args
     case _ => Nil
   }
 

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

@@ -790,7 +790,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     tycon1 match {
       case param1: TypeParamRef =>
         def canInstantiate = tp2 match {
-          case AnyAppliedType(tycon2, args2) =>
+          case AppliedType(tycon2, args2) =>
             tryInstantiate(param1, tycon2.ensureHK) && isSubArgs(args1, args2, tp1, tycon2.typeParams)
           case _ =>
             false

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

@@ -150,7 +150,7 @@ object Types {
     }
 
     def isInfixType(implicit ctx: Context): Boolean = this match {
-      case TypeApplications.AnyAppliedType(tycon, args) =>
+      case AppliedType(tycon, args) =>
         args.length == 2 &&
           !Character.isUnicodeIdentifierStart(tycon.typeSymbol.name.toString.head)
           // TODO: Once we use the 2.12 stdlib, also check the @showAsInfix annotation

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

@@ -139,7 +139,7 @@ class TreePickler(pickler: TastyPickler) {
   }
 
   private def pickleNewType(tpe: Type, richTypes: Boolean)(implicit ctx: Context): Unit = tpe match {
-    case AnyAppliedType(tycon, args) =>
+    case AppliedType(tycon, args) =>
       writeByte(APPLIEDtype)
       withLength { pickleType(tycon); args.foreach(pickleType(_)) }
     case ConstantType(value) =>

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -4,7 +4,6 @@ package printing
 import core._
 import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Constants._, Denotations._
 import Contexts.Context, Scopes.Scope, Denotations.Denotation, Annotations.Annotation
-import TypeApplications.AnyAppliedType
 import StdNames.{nme, tpnme}
 import ast.Trees._, ast._
 import typer.Implicits._
@@ -133,7 +132,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
    */
   private def refinementChain(tp: Type): List[Type] =
     tp :: (tp match {
-      case AnyAppliedType(_, _) => Nil // @!!!
+      case AppliedType(_, _) => Nil // @!!!
       case tp: RefinedType => refinementChain(tp.parent.stripTypeVar)
       case _ => Nil
     })
@@ -152,7 +151,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         toTextLocal(tp.underlying) ~ "(" ~ toTextRef(tp) ~ ")"
       case tp: TypeRef =>
         toTextPrefix(tp.prefix) ~ selectionString(tp)
-      case AnyAppliedType(tycon, args) =>
+      case AppliedType(tycon, args) =>
         (toTextLocal(tycon) ~ "[" ~ Text(args map argText, ", ") ~ "]").close
       case tp: RefinedType =>
         val parent :: (refined: List[RefinedType @unchecked]) =

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

@@ -141,7 +141,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     homogenize(tp) match {
       case x: ConstantType if homogenizedView =>
         return toText(x.widen)
-      case AnyAppliedType(tycon, args) =>
+      case AppliedType(tycon, args) =>
         val cls = tycon.typeSymbol
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
         if (defn.isFunctionClass(cls)) return toTextFunction(args, cls.name.isImplicitFunction)

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -370,7 +370,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         else
           tp.prefix
         new api.Projection(simpleType(prefix), sym.name.toString)
-      case TypeApplications.AnyAppliedType(tycon, args) =>
+      case AppliedType(tycon, args) =>
         def processArg(arg: Type): api.Type = arg match {
           case arg @ TypeBounds(lo, hi) => // Handle wildcard parameters
             if (lo.isDirectRef(defn.NothingClass) && hi.isDirectRef(defn.AnyClass))

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

@@ -6,7 +6,6 @@ import core._
 import ast._
 import Scopes._, Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
 import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._, TypeErasure._
-import TypeApplications.AnyAppliedType
 import util.Positions._
 import config.Printers.typr
 import ast.Trees._

doc-tool/src/dotty/tools/dottydoc/model/factories.scala

@@ -57,7 +57,7 @@ object factories {
     }
 
     def expandTpe(t: Type, params: List[Reference] = Nil): Reference = t match {
-      case AnyAppliedType(tycon, args) => {
+      case AppliedType(tycon, args) => {
         val cls = tycon.typeSymbol
 
         if (defn.isFunctionClass(cls))