Eliminate ParamType

Replace with ParamRef

Author: odersky

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

@@ -196,7 +196,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substParam(tp: Type, from: ParamType, to: Type, theMap: SubstParamMap): Type =
+  final def substParam(tp: Type, from: ParamRef, to: Type, theMap: SubstParamMap): Type =
     tp match {
       case tp: BoundType =>
         if (tp == from) to else tp
@@ -216,7 +216,7 @@ trait Substituters { this: Context =>
 
   final def substParams(tp: Type, from: BindingType, to: List[Type], theMap: SubstParamsMap): Type =
     tp match {
-      case tp: ParamType =>
+      case tp: ParamRef =>
         if (tp.binder == from) to(tp.paramNum) else tp
       case tp: NamedType =>
         if (tp.currentSymbol.isStatic) tp
@@ -269,7 +269,7 @@ trait Substituters { this: Context =>
     def apply(tp: Type): Type = substRecThis(tp, from, to, this)
   }
 
-  final class SubstParamMap(from: ParamType, to: Type) extends DeepTypeMap {
+  final class SubstParamMap(from: ParamRef, to: Type) extends DeepTypeMap {
     def apply(tp: Type) = substParam(tp, from, to, this)
   }
 

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

@@ -1199,7 +1199,7 @@ object Types {
       ctx.substRecThis(this, binder, tp, null)
 
     /** Substitute a bound type by some other type */
-    final def substParam(from: ParamType, to: Type)(implicit ctx: Context): Type =
+    final def substParam(from: ParamRef, to: Type)(implicit ctx: Context): Type =
       ctx.substParam(this, from, to, null)
 
     /** Substitute bound types by some other types */
@@ -2407,8 +2407,6 @@ object Types {
     type PInfo = Type
     type This <: TermLambda
 
-    def paramNames: List[TermName]
-
     override def resultType(implicit ctx: Context): Type =
       if (dependencyStatus == FalseDeps) { // dealias all false dependencies
         val dealiasMap = new TypeMap {
@@ -2827,21 +2825,17 @@ object Types {
       unique(new CachedHKApply(tycon, args)).checkInst
   }
 
-  // ----- Bound types: MethodParam, TypeParamRef --------------------------
+  // ----- BoundTypes: ParamRef, RecThis ----------------------------------------
 
   abstract class BoundType extends CachedProxyType with ValueType {
     type BT <: Type
     val binder: BT
     def copyBoundType(bt: BT): Type
   }
 
-  abstract class ParamType extends BoundType {
-    def paramNum: Int
-    def paramName: Name
-  }
-
-  abstract class ParamRef extends ParamType {
+  abstract class ParamRef extends BoundType {
     type BT <: LambdaType
+    def paramNum: Int
     def paramName: binder.ThisName = binder.paramNames(paramNum)
 
     override def underlying(implicit ctx: Context): Type = {

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

@@ -260,14 +260,14 @@ class TreePickler(pickler: TastyPickler) {
       writeByte(METHODtype)
       pickleMethodic(tpe.resultType, tpe.paramNames, tpe.paramInfos)
     case tpe: TypeParamRef =>
-      if (!pickleParamType(tpe))
+      if (!pickleParamRef(tpe))
       // TODO figure out why this case arises in e.g. pickling AbstractFileReader.
         ctx.typerState.constraint.entry(tpe) match {
           case TypeBounds(lo, hi) if lo eq hi => pickleNewType(lo, richTypes)
           case _ => assert(false, s"orphan poly parameter: $tpe")
         }
     case tpe: TermParamRef =>
-      assert(pickleParamType(tpe), s"orphan method parameter: $tpe")
+      assert(pickleParamRef(tpe), s"orphan method parameter: $tpe")
     case tpe: LazyRef =>
       pickleType(tpe.ref)
   }} catch {
@@ -289,7 +289,7 @@ class TreePickler(pickler: TastyPickler) {
       }
     }
 
-  def pickleParamType(tpe: ParamType)(implicit ctx: Context): Boolean = {
+  def pickleParamRef(tpe: ParamRef)(implicit ctx: Context): Boolean = {
     val binder = pickledTypes.get(tpe.binder)
     val pickled = binder != null
     if (pickled) {

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

@@ -424,7 +424,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         new api.Annotated(apiType(tpe), Array(apiAnnotation(annot)))
       case tp: ThisType =>
         apiThis(tp.cls)
-      case tp: ParamType =>
+      case tp: ParamRef =>
         // TODO: Distinguishing parameters based on their names alone is not enough,
         // the binder is also needed (at least for type lambdas).
         new api.ParameterRef(tp.paramName.toString)

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -296,7 +296,7 @@ class TreeChecker extends Phase with SymTransformer {
             definedBinders += tp
             mapOver(tp)
             definedBinders -= tp
-          case tp: ParamType =>
+          case tp: ParamRef =>
             assert(definedBinders.contains(tp.binder), s"orphan param: $tp")
           case tp: TypeVar =>
             apply(tp.underlying)