Drop withoutArgs

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -380,7 +380,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** new C(args), calling given constructor `constr` of C */
   def New(tp: Type, constr: TermSymbol, args: List[Tree])(implicit ctx: Context): Apply = {
     val targs = tp.argTypes
-    val tycon = tp.withoutArgs(targs)
+    val tycon = tp.typeConstructor
     New(tycon)
       .select(TermRef.withSig(tycon, constr))
       .appliedToTypes(targs)

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -296,9 +296,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         (tycon, targs)
       case TypedSplice(AppliedTypeTree(tycon, targs)) =>
         (TypedSplice(tycon), targs map (TypedSplice(_)))
-      case TypedSplice(tpt1: Tree) =>
+      case TypedSplice(tpt1: tpd.Tree) =>
+        val tycon = tpt1.tpe.typeConstructor
         val argTypes = tpt1.tpe.argTypesLo
-        val tycon = tpt1.tpe.withoutArgs(argTypes)
         def wrap(tpe: Type) = TypeTree(tpe) withPos tpt.pos
         (wrap(tycon), argTypes map wrap)
       case _ =>

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

@@ -103,7 +103,7 @@ object Annotations {
 
     private def resolveConstructor(atp: Type, args:List[Tree])(implicit ctx: Context): Tree = {
       val targs = atp.argTypes
-      tpd.applyOverloaded(New(atp withoutArgs targs), nme.CONSTRUCTOR, args, targs, atp, isAnnotConstructor = true)
+      tpd.applyOverloaded(New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp, isAnnotConstructor = true)
     }
 
     def applyResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation = {

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

@@ -173,17 +173,17 @@ class TypeApplications(val self: Type) extends AnyVal {
    */
   final def typeParams(implicit ctx: Context): List[TypeParamInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
     self match {
-      case self: ClassInfo =>
-        self.cls.typeParams
-      case self: HKTypeLambda =>
-        self.typeParams
       case self: TypeRef =>
         val tsym = self.symbol
         if (tsym.isClass) tsym.typeParams
         else if (!tsym.isCompleting) tsym.info.typeParams
         else Nil
+      case self: ClassInfo =>
+        self.cls.typeParams
+      case self: HKTypeLambda =>
+        self.typeParams
       case self: RefinedType =>
-        self.parent.typeParams.filterNot(_.paramName == self.refinedName) // @!!!
+        self.parent.typeParams
       case self: RecType =>
         self.parent.typeParams
       case _: SingletonType =>
@@ -432,12 +432,6 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => TypeAlias(self)
   }
 
-  /** The type arguments of this type's base type instance wrt. `base`.
-   *  Wildcard types in arguments are returned as TypeBounds instances.
-   */
-  final def baseArgInfos(base: Symbol)(implicit ctx: Context): List[Type] = // @!!! drop
-    self.baseType(base).argInfos
-
   /** Translate a type of the form From[T] to To[T], keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    *  Do the same for by name types => From[T] and => To[T]
@@ -446,9 +440,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
     case _ =>
-      if (self.derivesFrom(from))
-        if (ctx.erasedTypes) to.typeRef // @!!! can be dropped; appliedTo does the right thing anyway
-        else to.typeRef.appliedTo(self.baseType(from).argInfos)
+      if (self.derivesFrom(from)) to.typeRef.appliedTo(self.baseType(from).argInfos)
       else self
   }
 
@@ -480,21 +472,6 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** Argument types where existential types in arguments are approximated by their upper bound  */
   def argTypesHi(implicit ctx: Context) = argInfos.mapConserve(_.hiBound)
 
-  /** The core type without any type arguments.
-   *  @param `typeArgs` must be the type arguments of this type.
-   */
-  final def withoutArgs(typeArgs: List[Type]): Type = self match { // @!!! replace with typeConstructor?
-    case AppliedType(tycon, args) => tycon
-    case _ =>
-      typeArgs match {
-        case _ :: typeArgs1 =>
-          val RefinedType(tycon, _, _) = self // @!!!
-          tycon.withoutArgs(typeArgs1)
-        case nil =>
-          self
-      }
-  }
-
   /** If this is the image of a type argument; recover the type argument,
    *  otherwise NoType.
    */
@@ -514,6 +491,6 @@ class TypeApplications(val self: Type) extends AnyVal {
   def elemType(implicit ctx: Context): Type = self match {
     case defn.ArrayOf(elemtp) => elemtp
     case JavaArrayType(elemtp) => elemtp
-    case _ => baseArgInfos(defn.SeqClass).headOption.getOrElse(NoType)
+    case _ => self.baseType(defn.SeqClass).argInfos.headOption.getOrElse(NoType)
   }
 }

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -62,7 +62,7 @@ object Scala2Unpickler {
     case tp: MethodType =>
       val lastArg = tp.paramInfos.last
       assert(lastArg isRef defn.ArrayClass)
-      val elemtp0 :: Nil = lastArg.baseArgInfos(defn.ArrayClass)
+      val elemtp0 :: Nil = lastArg.baseType(defn.ArrayClass).argInfos
       val elemtp = elemtp0 match {
         case AndType(t1, t2) if t1.typeSymbol.isAbstractType && (t2 isRef defn.ObjectClass) =>
           t1 // drop intersection with Object for abstract types in varargs. UnCurry can handle them.
@@ -927,7 +927,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     // println(atp)
     val targs = atp.argTypes
 
-    tpd.applyOverloaded(tpd.New(atp withoutArgs targs), nme.CONSTRUCTOR, args, targs, atp)
+    tpd.applyOverloaded(tpd.New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
 }
 
   /** Read an annotation and as a side effect store it into

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

@@ -536,19 +536,15 @@ object RefChecks {
                     def subclassMsg(c1: Symbol, c2: Symbol) =
                       s": ${c1.showLocated} is a subclass of ${c2.showLocated}, but method parameter types must match exactly."
                     val addendum =
-                      if (abstractSym == concreteSym) {
-                        val paArgs = pa.argInfos
-                        val pcArgs = pc.argInfos
-                        val paConstr = pa.withoutArgs(paArgs)
-                        val pcConstr = pc.withoutArgs(pcArgs)
-                        (paConstr, pcConstr) match {
+                      if (abstractSym == concreteSym)
+                        (pa.typeConstructor, pc.typeConstructor) match {
                           case (TypeRef(pre1, _), TypeRef(pre2, _)) =>
                             if (pre1 =:= pre2) ": their type parameters differ"
                             else ": their prefixes (i.e. enclosing instances) differ"
                           case _ =>
                             ""
                         }
-                      } else if (abstractSym isSubClass concreteSym)
+                      else if (abstractSym isSubClass concreteSym)
                         subclassMsg(abstractSym, concreteSym)
                       else if (concreteSym isSubClass abstractSym)
                         subclassMsg(concreteSym, abstractSym)