Remove all traces of TypeArgRef

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -179,6 +179,4 @@ object Config {
 
   /** When in IDE, turn StaleSymbol errors into warnings instead of crashing */
   final val ignoreStaleInIDE = true
-
-  val newScheme = true
 }

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

@@ -527,14 +527,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         case _ => isSubType(tp1.widenExpr, restpe2)
       }
       compareExpr
-    case tp2: TypeArgRef =>
-      def sameTypeArgRef = tp1 match {
-        case tp1: TypeArgRef =>
-          tp1.clsRef == tp2.clsRef && tp1.idx == tp2.idx && tp1.prefix =:= tp2.prefix
-        case _ =>
-          false
-      }
-      sameTypeArgRef || isSubType(tp1, tp2.underlying.loBound) || fourthTry(tp1, tp2)
     case tp2 @ TypeBounds(lo2, hi2) =>
       def compareTypeBounds = tp1 match {
         case tp1 @ TypeBounds(lo1, hi1) =>
@@ -605,8 +597,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       isNewSubType(tp1.parent, tp2)
     case tp1: RecType =>
       isNewSubType(tp1.parent, tp2)
-    case tp1: TypeArgRef =>
-      isSubType(tp1.underlying.hiBound, tp2)
     case tp1: HKTypeLambda =>
       def compareHKLambda = tp1 match {
         case EtaExpansion(tycon1) => isSubType(tycon1, tp2)
@@ -829,9 +819,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
 
       def compareCaptured(arg1: Type, arg2: Type): Boolean = arg1 match {
         case arg1: TypeBounds =>
-          val captured =
-            if (Config.newScheme) TypeRef(tp1, tparam.asInstanceOf[TypeSymbol])
-            else TypeArgRef.fromParam(tp1, tparam.asInstanceOf[TypeSymbol])
+          val captured = TypeRef(tp1, tparam.asInstanceOf[TypeSymbol])
           isSubArg(captured, arg2)
         case _ =>
           false

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

@@ -187,7 +187,7 @@ object Types {
      *  from the ThisType of `symd`'s owner.
      */
     def isArgPrefix(symd: SymDenotation)(implicit ctx: Context) =
-      Config.newScheme && symd.is(ClassTypeParam) && {
+      symd.is(ClassTypeParam) && {
         this match {
           case tp: ThisType => tp.cls ne symd.owner
           case _ => true
@@ -1742,6 +1742,12 @@ object Types {
       def rebase(arg: Type) = arg.subst(typeParams, concretized)
 
       val idx = typeParams.indexOf(param)
+
+      assert(args.nonEmpty,
+      	i"""bad parameter reference $this at ${ctx.phase}
+      	   |the parameter is ${param.showLocated} but the prefix $prefix
+      	   |does not define any corresponding arguments."""
+
       val argInfo = args(idx) match {
         case arg: TypeBounds =>
           val v = param.paramVariance
@@ -1877,9 +1883,7 @@ object Types {
           while (tparams.nonEmpty && args.nonEmpty) {
             if (tparams.head.eq(tparam))
               return args.head match {
-                case _: TypeBounds =>
-                  if (Config.newScheme) TypeRef(pre, tparam)
-                  else TypeArgRef(pre, cls.typeRef, idx)
+                case _: TypeBounds => TypeRef(pre, tparam)
                 case arg => arg
               }
             tparams = tparams.tail
@@ -3045,7 +3049,7 @@ object Types {
     final val Provisional: DependencyStatus = 4  // set if dependency status can still change due to type variable instantiations
   }
 
-  // ----- Type application: LambdaParam, AppliedType, TypeArgRef ---------------------
+  // ----- Type application: LambdaParam, AppliedType ---------------------
 
   /** The parameter of a type lambda */
   case class LambdaParam(tl: TypeLambda, n: Int) extends ParamInfo {
@@ -3123,70 +3127,6 @@ object Types {
     }
   }
 
-  /** A reference to wildcard argument `p.<parameter X of class C>`
-   *  where `p: C[... _ ...]`
-   */
-  abstract case class TypeArgRef(prefix: Type, clsRef: TypeRef, idx: Int) extends CachedProxyType with ValueType {
-    assert(prefix.isInstanceOf[ValueType])
-    assert(idx >= 0)
-
-    private[this] var underlyingCache: Type = _
-    private[this] var underlyingCachePeriod = Nowhere
-
-    def computeUnderlying(implicit ctx: Context): Type = {
-      val cls = clsRef.symbol
-      val args = prefix.baseType(cls).argInfos
-      val typeParams = cls.typeParams
-
-      val concretized = TypeArgRef.concretizeArgs(args, prefix, clsRef)
-      def rebase(arg: Type) = arg.subst(typeParams, concretized)
-
-      val arg = args(idx)
-      val tparam = typeParams(idx)
-      val v = tparam.paramVariance
-      val pbounds = tparam.paramInfo
-      if (v > 0 && pbounds.loBound.dealias.isBottomType) arg.hiBound & rebase(pbounds.hiBound)
-      else if (v < 0 && pbounds.hiBound.dealias.isTopType) arg.loBound | rebase(pbounds.loBound)
-      else arg recoverable_& rebase(pbounds)
-    }
-
-    override def underlying(implicit ctx: Context): Type = {
-      if (!ctx.hasSameBaseTypesAs(underlyingCachePeriod)) {
-        underlyingCache = computeUnderlying
-        underlyingCachePeriod = ctx.period
-      }
-      underlyingCache
-    }
-
-    def derivedTypeArgRef(prefix: Type)(implicit ctx: Context): Type =
-      if (prefix eq this.prefix) this else TypeArgRef(prefix, clsRef, idx)
-    override def computeHash = doHash(idx, prefix, clsRef)
-
-    override def eql(that: Type) = that match {
-      case that: TypeArgRef => prefix.eq(that.prefix) && clsRef.eq(that.clsRef) && idx == that.idx
-      case _ => false
-    }
-  }
-
-  final class CachedTypeArgRef(prefix: Type, clsRef: TypeRef, idx: Int) extends TypeArgRef(prefix, clsRef, idx)
-
-  object TypeArgRef {
-    def apply(prefix: Type, clsRef: TypeRef, idx: Int)(implicit ctx: Context) =
-      unique(new CachedTypeArgRef(prefix, clsRef, idx))
-    def fromParam(prefix: Type, tparam: TypeSymbol)(implicit ctx: Context) = {
-      val cls = tparam.owner
-      apply(prefix, cls.typeRef, cls.typeParams.indexOf(tparam))
-    }
-
-    def concretizeArgs(args: List[Type], prefix: Type, clsRef: TypeRef)(implicit ctx: Context): List[Type] = {
-      def concretize(arg: Type, j: Int) = arg match {
-        case arg: TypeBounds => TypeArgRef(prefix, clsRef, j)
-        case arg => arg
-      }
-      args.zipWithConserve(args.indices.toList)(concretize)
-    }
-  }
-
   // ----- BoundTypes: ParamRef, RecThis ----------------------------------------
 
   abstract class BoundType extends CachedProxyType with ValueType {
@@ -3787,13 +3727,7 @@ object Types {
     def apply(tp: Type): Type
 
     protected def derivedSelect(tp: NamedType, pre: Type): Type =
-      tp.derivedSelect(pre) match {
-        case tp: TypeArgRef if variance != 0 =>
-          val tp1 = tp.underlying
-          if (variance > 0) tp1.hiBound else tp1.loBound
-        case tp =>
-          tp
-      }
+      tp.derivedSelect(pre)
     protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type): Type =
       tp.derivedRefinedType(parent, tp.refinedName, info)
     protected def derivedRecType(tp: RecType, parent: Type): Type =
@@ -3806,8 +3740,6 @@ object Types {
       tp.derivedSuperType(thistp, supertp)
     protected def derivedAppliedType(tp: AppliedType, tycon: Type, args: List[Type]): Type =
       tp.derivedAppliedType(tycon, args)
-    protected def derivedTypeArgRef(tp: TypeArgRef, prefix: Type): Type =
-      tp.derivedTypeArgRef(prefix)
     protected def derivedAndOrType(tp: AndOrType, tp1: Type, tp2: Type): Type =
       tp.derivedAndOrType(tp1, tp2)
     protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation): Type =
@@ -3892,9 +3824,6 @@ object Types {
           }
           mapOverLambda
 
-        case tp @ TypeArgRef(prefix, _, _) =>
-          derivedTypeArgRef(tp, atVariance(variance max 0)(this(prefix)))
-
         case tp @ SuperType(thistp, supertp) =>
           derivedSuperType(tp, this(thistp), this(supertp))
 
@@ -4018,27 +3947,39 @@ object Types {
     /** Try to widen a named type to its info relative to given prefix `pre`, where possible.
      *  The possible cases are listed inline in the code.
      */
-    def tryWiden(tp: NamedType, pre: Type): Type =
-      pre.member(tp.name) match {
-        case d: SingleDenotation =>
-          d.info match {
-            case TypeAlias(alias) =>
-              // if H#T = U, then for any x in L..H, x.T =:= U,
-              // hence we can replace with U under all variances
-              reapply(alias)
-            case TypeBounds(lo, hi) =>
-              // If H#T = _ >: S <: U, then for any x in L..H, S <: x.T <: U,
-              // hence we can replace with S..U under all variances
-              range(atVariance(-variance)(reapply(lo)), reapply(hi))
-            case info: SingletonType =>
-              // if H#x: y.type, then for any x in L..H, x.type =:= y.type,
-              // hence we can replace with y.type under all variances
-              reapply(info)
-            case _ =>
-              NoType
-          }
-        case _ => NoType
-      }
+    def tryWiden(tp: NamedType, pre: Type): Type = pre.member(tp.name) match {
+      case d: SingleDenotation =>
+        d.info match {
+          case TypeAlias(alias) =>
+            // if H#T = U, then for any x in L..H, x.T =:= U,
+            // hence we can replace with U under all variances
+            reapply(alias)
+          case TypeBounds(lo, hi) =>
+            // If H#T = _ >: S <: U, then for any x in L..H, S <: x.T <: U,
+            // hence we can replace with S..U under all variances
+            range(atVariance(-variance)(reapply(lo)), reapply(hi))
+          case info: SingletonType =>
+            // if H#x: y.type, then for any x in L..H, x.type =:= y.type,
+            // hence we can replace with y.type under all variances
+            reapply(info)
+          case _ =>
+            NoType
+        }
+      case _ => NoType
+    }
+
+    /** Expand parameter reference corresponding to prefix `pre`;
+     *  If the expansion is a wildcard parameter reference, convert its
+     *  underlying bounds to a range, otherwise return the expansion.
+     */
+    def expandParam(tp: NamedType, pre: Type) = tp.argForParam(pre) match {
+      case arg @ TypeRef(pre, _) if pre.isArgPrefix(arg.symbol) =>
+        arg.info match {
+          case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
+          case arg => reapply(arg)
+        }
+      case arg => reapply(arg)
+    }
 
     /** Derived selection.
      *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
@@ -4048,21 +3989,7 @@ object Types {
       else pre match {
         case Range(preLo, preHi) =>
           val forwarded =
-            if (tp.symbol.is(ClassTypeParam)) {
-              tp.argForParam(preHi) match {
-                case arg: TypeArgRef =>
-                  arg.underlying match {
-                    case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
-                    case arg => reapply(arg)
-                  }
-                case arg @ TypeRef(pre, _) if pre.isArgPrefix(arg.symbol) =>
-                  arg.info match {
-                    case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
-                    case arg => reapply(arg)
-                  }
-                case arg => reapply(arg)
-              }
-            }
+            if (tp.symbol.is(ClassTypeParam)) expandParam(tp, preHi)
             else tryWiden(tp, preHi)
           forwarded.orElse(
             range(super.derivedSelect(tp, preLo), super.derivedSelect(tp, preHi)))
@@ -4165,14 +4092,6 @@ object Types {
         else range(lower(tp1) | lower(tp2), upper(tp1) | upper(tp2))
       else tp.derivedAndOrType(tp1, tp2)
 
-    override protected def derivedTypeArgRef(tp: TypeArgRef, prefix: Type): Type =
-      if (isRange(prefix)) // TODO: explain
-        tp.underlying match {
-          case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
-          case _ => range(tp.bottomType, tp.topType)
-        }
-      else tp.derivedTypeArgRef(prefix)
-
     override protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation) =
       underlying match {
         case Range(lo, hi) =>
@@ -4308,9 +4227,6 @@ object Types {
       case tp: SkolemType =>
         this(x, tp.info)
 
-      case tp @ TypeArgRef(prefix, _, _) =>
-        atVariance(variance max 0)(this(x, prefix))
-
       case SuperType(thistp, supertp) =>
         this(this(x, thistp), supertp)
 

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

@@ -168,7 +168,6 @@ Standard-Section: "ASTs" TopLevelStat*
                                         // for type-variables defined in a type pattern
                   BYNAMEtype            underlying_Type
                   PARAMtype      Length binder_ASTref paramNum_Nat
-                  TYPEARGtype    Length prefix_Type clsRef_Type idx_Nat
                   POLYtype       Length result_Type NamesTypes
                   METHODtype     Length result_Type NamesTypes      // needed for refinements
                   TYPELAMBDAtype Length result_Type NamesTypes      // variance encoded in front of name: +/-/(nothing)
@@ -394,7 +393,6 @@ object TastyFormat {
   final val LAMBDAtpt = 173
   final val PARAMtype = 174
   final val ANNOTATION = 175
-  final val TYPEARGtype = 176
   final val TERMREFin = 177
   final val TYPEREFin = 178
 
@@ -580,7 +578,6 @@ object TastyFormat {
     case SYMBOLconst => "SYMBOLconst"
     case SINGLETONtpt => "SINGLETONtpt"
     case SUPERtype => "SUPERtype"
-    case TYPEARGtype => "TYPEARGtype"
     case TERMREFin => "TERMREFin"
     case TYPEREFin => "TYPEREFin"
     case REFINEDtype => "REFINEDtype"

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

@@ -211,9 +211,6 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: SuperType =>
       writeByte(SUPERtype)
       withLength { pickleType(tpe.thistpe); pickleType(tpe.supertpe) }
-    case tpe: TypeArgRef =>
-      writeByte(TYPEARGtype)
-      withLength { pickleType(tpe.prefix); pickleType(tpe.clsRef); writeNat(tpe.idx) }
     case tpe: RecThis =>
       writeByte(RECthis)
       val binderAddr = pickledTypes.get(tpe.binder)

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

@@ -259,8 +259,6 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
               OrType(readType(), readType())
             case SUPERtype =>
               SuperType(readType(), readType())
-            case TYPEARGtype =>
-              TypeArgRef(readType(), readType().asInstanceOf[TypeRef], readNat())
             case BIND =>
               val sym = ctx.newSymbol(ctx.owner, readName().toTypeName, BindDefinedType, readType())
               registerSym(start, sym)

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

@@ -176,11 +176,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
           "{" ~ selfRecName(openRecs.length) ~ " => " ~ toTextGlobal(tp.parent) ~ "}"
         }
         finally openRecs = openRecs.tail
-      case TypeArgRef(prefix, clsRef, idx) =>
-        val cls = clsRef.symbol
-        val tparams = cls.typeParams
-        val paramName = if (tparams.length > idx) nameString(tparams(idx)) else "<unknown>"
-        toTextPrefix(prefix) ~ s"<parameter $paramName of " ~ toText(cls) ~ ">"
       case AndType(tp1, tp2) =>
         changePrec(AndPrec) { toText(tp1) ~ " & " ~ toText(tp2) }
       case OrType(tp1, tp2) =>

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

@@ -31,11 +31,6 @@ class UserFacingPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
 
   override def toText(const: Constant): Text = Str(const.value.toString)
 
-  override def argText(tp: Type): Text = tp match {
-    case arg: TypeArgRef => argText(arg.underlying)
-    case _ => super.argText(tp)
-  }
-
   override def toText(tp: Type): Text = tp match {
     case ExprType(result) => ":" ~~ toText(result)
     case tp: ConstantType => toText(tp.value)

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

@@ -147,7 +147,6 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     new api.Annotated(tp, Array(marker))
   private def marker(name: String) =
     new api.Annotation(new api.Constant(Constants.emptyType, name), Array())
-  val typeArgRefMarker = marker("TypeArgRef")
   val orMarker = marker("Or")
   val byNameMarker = marker("ByName")
 
@@ -478,9 +477,6 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         apiType(tp.ref)
       case tp: TypeVar =>
         apiType(tp.underlying)
-      case TypeArgRef(prefix, clsRef, idx) =>
-        val apiClsWithIdx = withMarker(apiType(clsRef), marker(idx.toString))
-        withMarker(combineApiTypes(apiType(prefix), apiClsWithIdx), typeArgRefMarker)
       case _ => {
         ctx.warning(i"sbt-api: Unhandled type ${tp.getClass} : $tp")
         Constants.emptyType

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -96,6 +96,7 @@ class CompilationTests extends ParallelTesting {
     compileFilesInDir("../tests/new", defaultOptions) +
     compileFilesInDir("../tests/pos-scala2", scala2Mode) +
     compileFilesInDir("../tests/pos", defaultOptions) +
+    compileFilesInDir("../tests/pos-no-optimise", defaultOptions) +
     compileFilesInDir("../tests/pos-deep-subtype", allowDeepSubtypes) +
     compileDir("../tests/pos/i1137-1", defaultOptions and "-Yemit-tasty") +
     compileFile(