Drop WithBounds annotation

Use new three-element TypeBoundsTree to represent bounded opaque aliases instead.

Author: odersky

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

@@ -1156,7 +1156,8 @@ object desugar {
   val legalOpaque: MemberDefTest = {
     case TypeDef(_, rhs) =>
       def rhsOK(tree: Tree): Boolean = tree match {
-        case _: TypeBoundsTree | _: Template => false
+        case bounds: TypeBoundsTree => !bounds.alias.isEmpty
+        case _: Template => false
         case LambdaTypeTree(_, body) => rhsOK(body)
         case _ => true
       }

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

@@ -814,8 +814,6 @@ object Trees {
     extends ProxyTree[T] {
     type ThisTree[-T >: Untyped] = Annotated[T]
     def forwardTo: Tree[T] = arg
-    override def disableOverlapChecks = true
-      // disable overlaps checks since the WithBounds annotation swaps type and annotation.
   }
 
   trait WithoutTypeOrPos[-T >: Untyped] extends Tree[T] {

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

@@ -173,22 +173,6 @@ object Annotations {
         else None
     }
 
-    /** Extractor for WithBounds[T] annotations */
-    object WithBounds {
-      def unapply(ann: Annotation)(implicit ctx: Context): Option[TypeBounds] =
-        if (ann.symbol == defn.WithBoundsAnnot) {
-          import ast.Trees._
-          // We need to extract the type of the type tree in the New itself.
-          // The annotation's type has been simplified as the type of an expression,
-          // which means that `&` or `|` might have been lost.
-          // Test in pos/reference/opaque.scala
-          val Apply(TypeApply(Select(New(tpt), nme.CONSTRUCTOR), _), Nil) = ann.tree
-          val AppliedType(_, lo :: hi :: Nil) = tpt.tpe
-          Some(TypeBounds(lo, hi))
-        }
-        else None
-    }
-
     def makeSourceFile(path: String)(implicit ctx: Context): Annotation =
       apply(defn.SourceFileAnnot, Literal(Constant(path)))
   }

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

@@ -784,7 +784,6 @@ class Definitions {
   @tu lazy val AnnotationDefaultAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.AnnotationDefault")
   @tu lazy val BodyAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.Body")
   @tu lazy val ChildAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.Child")
-  @tu lazy val WithBoundsAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.WithBounds")
   @tu lazy val CovariantBetweenAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.CovariantBetween")
   @tu lazy val ContravariantBetweenAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.ContravariantBetween")
   @tu lazy val DeprecatedAnnot: ClassSymbol = ctx.requiredClass("scala.deprecated")

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

@@ -11,6 +11,7 @@ import Scopes.Scope
 import dotty.tools.io.AbstractFile
 import Decorators.SymbolIteratorDecorator
 import ast._
+import ast.Trees.{LambdaTypeTree, TypeBoundsTree}
 import Trees.Literal
 import Variances.Variance
 import annotation.tailrec
@@ -433,8 +434,9 @@ object SymDenotations {
      *
      *  @param info   Is assumed to be a (lambda-abstracted) right hand side TypeAlias
      *                of the opaque type definition.
+     *  @param rhs    The right hand side tree of the type definition
      */
-    def opaqueToBounds(info: Type)(given Context): Type =
+    def opaqueToBounds(info: Type, rhs: tpd.Tree)(given Context): Type =
 
       def setAlias(tp: Type) =
         def recur(self: Type): Unit = self match
@@ -446,21 +448,19 @@ object SymDenotations {
         recur(owner.asClass.givenSelfType)
       end setAlias
 
-      def split(tp: Type): (Type, TypeBounds) = tp match
-        case AnnotatedType(alias, Annotation.WithBounds(bounds)) =>
-          (alias, bounds)
-        case tp: HKTypeLambda =>
-          val (alias1, bounds1) = split(tp.resType)
-          (tp.derivedLambdaType(resType = alias1),
-           HKTypeLambda.boundsFromParams(tp.typeParams, bounds1))
+      def bounds(t: tpd.Tree): TypeBounds = t match
+        case LambdaTypeTree(_, body) =>
+          bounds(body)
+        case TypeBoundsTree(lo, hi, alias) =>
+          assert(!alias.isEmpty)
+          TypeBounds(lo.tpe, hi.tpe)
         case _ =>
-          (tp, HKTypeLambda.boundsFromParams(tp.typeParams, TypeBounds.empty))
+          TypeBounds.empty
 
       info match
-        case TypeAlias(tp) if isOpaqueAlias && owner.isClass =>
-          val (alias, bounds) = split(tp)
+        case TypeAlias(alias) if isOpaqueAlias && owner.isClass =>
           setAlias(alias)
-          bounds
+          HKTypeLambda.boundsFromParams(alias.typeParams, bounds(rhs))
         case _ =>
           info
     end opaqueToBounds

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

@@ -833,11 +833,12 @@ class TreeUnpickler(reader: TastyReader,
               override def completerTypeParams(sym: Symbol)(implicit ctx: Context) =
                 rhs.tpe.typeParams
             }
-            sym.info = sym.opaqueToBounds {
-              rhs.tpe match
+            sym.info = sym.opaqueToBounds(
+              rhs.tpe match {
                 case _: TypeBounds | _: ClassInfo => checkNonCyclic(sym, rhs.tpe, reportErrors = false)
                 case _ => rhs.tpe.toBounds
-            }
+              },
+              rhs)
             if sym.isOpaqueAlias then sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
             sym.resetFlag(Provisional)
             TypeDef(rhs)

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3348,14 +3348,10 @@ object Parsers {
                       syntaxError(i"cannot combine lower bound and match type alias", eqOffset)
                   }
                 case _ =>
-                  if (mods.is(Opaque)) {
-                    val annotType = AppliedTypeTree(
-                      TypeTree(defn.WithBoundsAnnot.typeRef),
-                        bounds.lo.orElse(TypeTree(defn.NothingType)) ::
-                        bounds.hi.orElse(TypeTree(defn.AnyType)) :: Nil)
-                    rhs = Annotated(rhs, ensureApplied(wrapNew(annotType)))
-                  }
-                  else syntaxError(i"cannot combine bound and alias", eqOffset)
+                  if mods.is(Opaque) then
+                    rhs = TypeBoundsTree(bounds.lo, bounds.hi, rhs)
+                  else
+                    syntaxError(i"cannot combine bound and alias", eqOffset)
               }
               makeTypeDef(rhs)
             }

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

@@ -997,12 +997,13 @@ class Namer { typer: Typer =>
       }
       sym.info = dummyInfo2
 
-      val rhsBodyType: TypeBounds = typedAheadType(rhs).tpe.toBounds
+      val rhs1 = typedAheadType(rhs)
+      val rhsBodyType: TypeBounds = rhs1.tpe.toBounds
       val unsafeInfo = if (isDerived) rhsBodyType else abstracted(rhsBodyType)
       if (isDerived) sym.info = unsafeInfo
       else {
         sym.info = NoCompleter
-        sym.info = sym.opaqueToBounds(checkNonCyclic(sym, unsafeInfo, reportErrors = true))
+        sym.info = sym.opaqueToBounds(checkNonCyclic(sym, unsafeInfo, reportErrors = true), rhs1)
       }
       if sym.isOpaqueAlias then sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
       sym.resetFlag(Provisional)

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

@@ -1515,6 +1515,11 @@ class Typer extends Namer
     val lo2 = if (lo1.isEmpty) typed(untpd.TypeTree(defn.NothingType)) else lo1
     val hi2 = if (hi1.isEmpty) typed(untpd.TypeTree(defn.AnyType)) else hi1
 
+    if !alias1.isEmpty then
+      val bounds = TypeBounds(lo2.tpe, hi2.tpe)
+      if !bounds.contains(alias1.tpe) then
+        ctx.error(em"type ${alias1.tpe} outside bounds $bounds", tree.sourcePos)
+
     val tree1 = assignType(cpy.TypeBoundsTree(tree)(lo2, hi2, alias1), lo2, hi2, alias1)
     if (ctx.mode.is(Mode.Pattern))
       // Associate a pattern-bound type symbol with the wildcard.
@@ -1952,13 +1957,7 @@ class Typer extends Namer
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type) {
       if arg1.isType then
-        val result = assignType(cpy.Annotated(tree)(arg1, annot1), arg1, annot1)
-        result.tpe match {
-          case AnnotatedType(rhs, Annotation.WithBounds(bounds)) =>
-            if (!bounds.contains(rhs)) ctx.error(em"type $rhs outside bounds $bounds", tree.sourcePos)
-          case _ =>
-        }
-        result
+        assignType(cpy.Annotated(tree)(arg1, annot1), arg1, annot1)
       else
         assert(ctx.reporter.errorsReported)
         TypeTree(UnspecifiedErrorType)