Make ParamRefs unique types.

They were case classes before, but not uniquely hashed. This meant that
the hash cons sepcialization for AppliedTypes failed to work in many cases.
since ParamRef arguments were not `eq` to each other. Consequently, we
got timeouts for compiling stdlib. (reverted from commit edd518f)

Author: odersky

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

@@ -463,12 +463,12 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       (poly, entries) <- boundsMap.toList
       n <- 0 until paramCount(entries)
       if entries(n).exists
-    } yield TypeParamRef.uncached(poly, n)
+    } yield TypeParamRef(poly, n)
 
   def forallParams(p: TypeParamRef => Boolean): Boolean = {
     boundsMap.foreachBinding { (poly, entries) =>
       for (i <- 0 until paramCount(entries))
-        if (isBounds(entries(i)) && !p(TypeParamRef.uncached(poly, i))) return false
+        if (isBounds(entries(i)) && !p(TypeParamRef(poly, i))) return false
     }
     true
   }

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

@@ -2634,7 +2634,7 @@ object Types {
     def paramNames: List[ThisName]
     def paramInfos: List[PInfo]
     def resType: Type
-    def newParamRef(n: Int)(implicit ctx: Context): ParamRefType
+    def newParamRef(n: Int): ParamRefType
 
     override def resultType(implicit ctx: Context) = resType
 
@@ -2648,12 +2648,7 @@ object Types {
     final def isTypeLambda = isInstanceOf[TypeLambda]
     final def isHigherKinded = isInstanceOf[TypeProxy]
 
-    private var myParamRefs: List[ParamRefType] = null
-
-    def paramRefs(implicit ctx: Context): List[ParamRefType] = {
-      if (myParamRefs == null) myParamRefs = paramNames.indices.toList.map(newParamRef)
-      myParamRefs
-    }
+    lazy val paramRefs: List[ParamRefType] = paramNames.indices.toList.map(newParamRef)
 
     protected def computeSignature(implicit ctx: Context) = resultSignature
 
@@ -2814,7 +2809,7 @@ object Types {
      */
     def isParamDependent(implicit ctx: Context): Boolean = paramDependencyStatus == TrueDeps
 
-    def newParamRef(n: Int)(implicit ctx: Context) = TermParamRef(this, n)
+    def newParamRef(n: Int) = TermParamRef(this, n)
   }
 
   abstract case class MethodType(paramNames: List[TermName])(
@@ -2969,7 +2964,7 @@ object Types {
     def isDependent(implicit ctx: Context): Boolean = true
     def isParamDependent(implicit ctx: Context): Boolean = true
 
-    def newParamRef(n: Int)(implicit ctx: Context) = TypeParamRef(this, n)
+    def newParamRef(n: Int) = TypeParamRef(this, n)
 
     lazy val typeParams: List[LambdaParam] =
       paramNames.indices.toList.map(new LambdaParam(this, _))
@@ -3127,7 +3122,7 @@ object Types {
     def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = paramInfo
     def paramInfoOrCompleter(implicit ctx: Context): Type = paramInfo
     def paramVariance(implicit ctx: Context): Int = tl.paramNames(n).variance
-    def toArg(implicit ctx: Context): Type = TypeParamRef(tl, n)
+    def toArg: Type = TypeParamRef(tl, n)
     def paramRef(implicit ctx: Context): Type = TypeParamRef(tl, n)
   }
 
@@ -3341,7 +3336,7 @@ object Types {
   abstract class BoundType extends CachedProxyType with ValueType {
     type BT <: Type
     val binder: BT
-    def copyBoundType(bt: BT)(implicit ctx: Context): Type
+    def copyBoundType(bt: BT): Type
   }
 
   abstract class ParamRef extends BoundType {
@@ -3370,21 +3365,14 @@ object Types {
       }
   }
 
-  abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef {
+  case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef {
     type BT = TermLambda
-    def copyBoundType(bt: BT)(implicit ctx: Context) = TermParamRef(bt, paramNum)
-  }
-
-  class CachedTermParamRef(binder: TermLambda, paramNum: Int) extends TermParamRef(binder, paramNum)
-
-  object TermParamRef {
-    def apply(binder: TermLambda, paramNum: Int)(implicit ctx: Context) =
-      unique(new CachedTermParamRef(binder, paramNum))
+    def copyBoundType(bt: BT) = TermParamRef(bt, paramNum)
   }
 
-  abstract case class TypeParamRef(binder: TypeLambda, paramNum: Int) extends ParamRef {
+  case class TypeParamRef(binder: TypeLambda, paramNum: Int) extends ParamRef {
     type BT = TypeLambda
-    def copyBoundType(bt: BT)(implicit ctx: Context) = TypeParamRef(bt, paramNum)
+    def copyBoundType(bt: BT) = TypeParamRef(bt, paramNum)
 
     /** Looking only at the structure of `bound`, is one of the following true?
      *     - fromBelow and param <:< bound
@@ -3400,21 +3388,11 @@ object Types {
     }
   }
 
-  class ConcreteTypeParamRef(binder: TypeLambda, paramNum: Int) extends TypeParamRef(binder, paramNum)
-
-  object TypeParamRef {
-    def apply(binder: TypeLambda, paramNum: Int)(implicit ctx: Context) =
-      unique(new ConcreteTypeParamRef(binder, paramNum))
-      
-    def uncached(binder: TypeLambda, paramNum: Int) =
-      new ConcreteTypeParamRef(binder: TypeLambda, paramNum: Int)
-  }
-
   /** a self-reference to an enclosing recursive type. */
   case class RecThis(binder: RecType) extends BoundType with SingletonType {
     type BT = RecType
     override def underlying(implicit ctx: Context) = binder
-    def copyBoundType(bt: BT)(implicit ctx: Context) = RecThis(bt)
+    def copyBoundType(bt: BT) = RecThis(bt)
 
     // need to customize hashCode and equals to prevent infinite recursion
     // between RecTypes and RecRefs.

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

@@ -409,7 +409,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           def addTyped(arg: Arg, formal: Type): Type => Type = {
             addArg(typedArg(arg, formal), formal)
             if (methodType.isParamDependent)
-              safeSubstParam(_, methodType.paramRefs.apply(n), typeOfArg(arg))
+              safeSubstParam(_, methodType.paramRefs(n), typeOfArg(arg))
             else identity
           }