Utility functions to test whether a type is a TypeBounds

Author: odersky

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

@@ -166,8 +166,6 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     entries != null && isBounds(entries(pnum)) && (typeVar(entries, pnum) eq tvar)
   }
 
-  private def isBounds(tp: Type) = tp.isInstanceOf[TypeBounds]
-
 // ---------- Dependency handling ----------------------------------------------
 
   def lower(param: TypeParamRef): List[TypeParamRef] = lowerLens(this, param.binder, param.paramNum)

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

@@ -106,7 +106,7 @@ object TypeApplications {
     private[this] var available = (0 until args.length).toSet
     var allReplaced: Boolean = true
     def hasWildcardArg(p: TypeParamRef): Boolean =
-      p.binder == tycon && args(p.paramNum).isInstanceOf[TypeBounds]
+      p.binder == tycon && isBounds(args(p.paramNum))
     def canReduceWildcard(p: TypeParamRef): Boolean =
       !ctx.mode.is(Mode.AllowLambdaWildcardApply) || available.contains(p.paramNum)
     def atNestedLevel(op: => Type): Type = {
@@ -356,7 +356,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     else dealiased match {
       case dealiased: HKTypeLambda =>
         def tryReduce =
-          if (!args.exists(_.isInstanceOf[TypeBounds])) {
+          if (!args.exists(isBounds)) {
             val followAlias = Config.simplifyApplications && {
               dealiased.resType match {
                 case AppliedType(tyconBody, dealiasedArgs) =>

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

@@ -1519,7 +1519,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
           if (common.exists) common
           else if (v > 0) glb(arg1.hiBound, arg2.hiBound)
           else if (v < 0) lub(arg1.loBound, arg2.loBound)
-          else if (arg1.isInstanceOf[TypeBounds] || arg2.isInstanceOf[TypeBounds])
+          else if (isBounds(arg1) || isBounds(arg2))
             TypeBounds(lub(arg1.loBound, arg2.loBound),
                        glb(arg1.hiBound, arg2.hiBound))
           else if (homogenizeArgs && !frozenConstraint && isSameType(arg1, arg2)) arg1

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

@@ -2067,7 +2067,7 @@ object Types {
           var tp1 = argForParam(base.tp1)
           var tp2 = argForParam(base.tp2)
           val variance = tparam.paramVariance
-          if (tp1.isInstanceOf[TypeBounds] || tp2.isInstanceOf[TypeBounds] || variance == 0) {
+          if (isBounds(tp1) || isBounds(tp2) || variance == 0) {
             // compute argument as a type bounds instead of a point type
             tp1 = tp1.bounds
             tp2 = tp2.bounds
@@ -3479,6 +3479,8 @@ object Types {
       if (tparams.isEmpty) HKTypeLambda.any(args.length).typeParams else tparams
     }
 
+    def hasWildcardArg(implicit ctx: Context): Boolean = args.exists(isBounds)
+
     def derivedAppliedType(tycon: Type, args: List[Type])(implicit ctx: Context): Type =
       if ((tycon eq this.tycon) && (args eq this.args)) this
       else tycon.appliedTo(args)
@@ -3619,7 +3621,7 @@ object Types {
   /** A skolem type reference with underlying type `info`.
    *  Note: `info` is a var, since this allows one to create a number of skolem types
    *  and fill in their infos with types that refers to the skolem types recursively.
-   *  This is used in `captureWildcards` in Typer`.
+   *  This is used in `captureWildcards` in `Typer`.
    */
   case class SkolemType(var info: Type) extends UncachedProxyType with ValueType with SingletonType {
     override def underlying(implicit ctx: Context): Type = info
@@ -5091,4 +5093,6 @@ object Types {
   private val keepAlways: AnnotatedType => Context => Boolean = _ => _ => true
   private val keepNever: AnnotatedType => Context => Boolean = _ => _ => false
   private val keepIfRefining: AnnotatedType => Context => Boolean = tp => ctx => tp.isRefining(ctx)
+
+  val isBounds: Type => Boolean = _.isInstanceOf[TypeBounds]
 }

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

@@ -476,7 +476,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             typeDefText(tparamsTxt, toText(rhs))
           case LambdaTypeTree(tparams, body) =>
             recur(body, tparamsText(tparams))
-          case rhs: TypeTree if rhs.typeOpt.isInstanceOf[TypeBounds] =>
+          case rhs: TypeTree if isBounds(rhs.typeOpt) =>
             typeDefText(tparamsTxt, toText(rhs))
           case rhs =>
             typeDefText(tparamsTxt, optText(rhs)(" = " ~ _))

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

@@ -81,7 +81,7 @@ object TypeTestsCasts {
     /** Approximate type parameters depending on variance */
     def stripTypeParam(tp: Type)(implicit ctx: Context) = new ApproximatingTypeMap {
       def apply(tp: Type): Type = tp match {
-        case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
+        case tp: TypeRef if isBounds(tp.underlying) =>
           val lo = apply(tp.info.loBound)
           val hi = apply(tp.info.hiBound)
           range(lo, hi)

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -624,15 +624,15 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         if (maximize) lo else hi
 
     def apply(tp: Type): Type = tp match {
-      case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
+      case tp: TypeRef if isBounds(tp.underlying) =>
         val lo = this(tp.info.loBound)
         val hi = this(tp.info.hiBound)
         // See tests/patmat/gadt.scala  tests/patmat/exhausting.scala  tests/patmat/t9657.scala
         val exposed = expose(lo, hi)
         debug.println(s"$tp exposed to =====> $exposed")
         exposed
 
-      case AppliedType(tycon: TypeRef, args) if tycon.underlying.isInstanceOf[TypeBounds] =>
+      case AppliedType(tycon: TypeRef, args) if isBounds(tycon.underlying) =>
         val args2 = args.map(this)
         val lo = this(tycon.info.loBound).applyIfParameterized(args2)
         val hi = this(tycon.info.hiBound).applyIfParameterized(args2)

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

@@ -1075,7 +1075,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         }
 
         var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.sourcePos)
-        for (argType <- argTypes) assert(!argType.isInstanceOf[TypeBounds], unapplyApp.tpe.show)
+        for (argType <- argTypes) assert(!isBounds(argType), unapplyApp.tpe.show)
         val bunchedArgs =
           if (argTypes.nonEmpty && argTypes.last.isRepeatedParam)
             args.lastOption match {

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

@@ -80,8 +80,8 @@ object Checking {
     if (boundsCheck) checkBounds(orderedArgs, bounds, instantiate)
 
     def checkWildcardApply(tp: Type): Unit = tp match {
-      case tp @ AppliedType(tycon, args) =>
-        if (tycon.isLambdaSub && args.exists(_.isInstanceOf[TypeBounds]))
+      case tp @ AppliedType(tycon, _) =>
+        if (tycon.isLambdaSub && tp.hasWildcardArg)
           ctx.errorOrMigrationWarning(
             ex"unreducible application of higher-kinded type $tycon to wildcard arguments",
             tree.sourcePos)

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

@@ -80,7 +80,6 @@ object Typer {
    */
   private[typer] val HiddenSearchFailure = new Property.Key[SearchFailure]
 
-  val isBounds: Type => Boolean = _.isInstanceOf[TypeBounds]
 }
 
 class Typer extends Namer
@@ -2708,7 +2707,7 @@ class Typer extends Namer
       case tp: RecType => tp.derivedRecType(captureWildcards(tp.parent))
       case tp: LazyRef => captureWildcards(tp.ref)
       case tp: AnnotatedType => tp.derivedAnnotatedType(captureWildcards(tp.parent), tp.annot)
-      case tp @ AppliedType(tycon, args) if args.exists(isBounds) =>
+      case tp @ AppliedType(tycon, args) if tp.hasWildcardArg =>
         tycon.typeParams match {
           case tparams @ ((_: Symbol) :: _) =>
             val args1 = args.map {