Generalize TypeBoundsTree to bounded opaque aliases

The RHS of an opaque type can consist of three parts:
```
  >: loBound <: hiBound = alias
```
This is encoded sp far in WithBounds annotation, but that mechanism means
hidden complexity for the Tasty standard. We now encode the alias directly,
as an optional third argument to a TypeBoundsTree structure.

Author: odersky

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

@@ -252,7 +252,7 @@ object desugar {
 
     if (meth1.mods.is(Inline))
       meth1.tpt match {
-        case TypeBoundsTree(_, tpt1) =>
+        case TypeBoundsTree(_, tpt1, _) =>
           meth1 = cpy.DefDef(meth1)(tpt = tpt1)
         case tpt if !tpt.isEmpty && !meth1.rhs.isEmpty =>
           meth1 = cpy.DefDef(meth1)(rhs = Typed(meth1.rhs, tpt))
@@ -684,7 +684,7 @@ object desugar {
           val mods = constr1.mods
           mods.is(Private) || (!mods.is(Protected) && mods.hasPrivateWithin)
         }
- 
+
         /** Does one of the parameter's types (in the first param clause)
          *  mention a preceding parameter?
          */

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

@@ -690,8 +690,10 @@ object Trees {
     type ThisTree[-T >: Untyped] = ByNameTypeTree[T]
   }
 
-  /** >: lo <: hi */
-  case class TypeBoundsTree[-T >: Untyped] private[ast] (lo: Tree[T], hi: Tree[T])(implicit @constructorOnly src: SourceFile)
+  /** >: lo <: hi
+   *  >: lo <: hi = alias  for RHS of bounded opaque type
+   */
+  case class TypeBoundsTree[-T >: Untyped] private[ast] (lo: Tree[T], hi: Tree[T], alias: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TypTree[T] {
     type ThisTree[-T >: Untyped] = TypeBoundsTree[T]
   }
@@ -760,7 +762,8 @@ object Trees {
   /** mods class name template     or
    *  mods trait name template     or
    *  mods type name = rhs   or
-   *  mods type name >: lo <: hi, if rhs = TypeBoundsTree(lo, hi) & (lo ne hi)
+   *  mods type name >: lo <: hi,          if rhs = TypeBoundsTree(lo, hi)      or
+   *  mods type name >: lo <: hi = rhs     if rhs = TypeBoundsTree(lo, hi, alias) and opaque in mods
    */
   case class TypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends MemberDef[T] {
@@ -1151,9 +1154,9 @@ object Trees {
         case tree: ByNameTypeTree if (result eq tree.result) => tree
         case _ => finalize(tree, untpd.ByNameTypeTree(result)(sourceFile(tree)))
       }
-      def TypeBoundsTree(tree: Tree)(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree = tree match {
-        case tree: TypeBoundsTree if (lo eq tree.lo) && (hi eq tree.hi) => tree
-        case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi)(sourceFile(tree)))
+      def TypeBoundsTree(tree: Tree)(lo: Tree, hi: Tree, alias: Tree)(implicit ctx: Context): TypeBoundsTree = tree match {
+        case tree: TypeBoundsTree if (lo eq tree.lo) && (hi eq tree.hi) && (alias eq tree.alias) => tree
+        case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi, alias)(sourceFile(tree)))
       }
       def Bind(tree: Tree)(name: Name, body: Tree)(implicit ctx: Context): Bind = tree match {
         case tree: Bind if (name eq tree.name) && (body eq tree.body) => tree
@@ -1304,8 +1307,8 @@ object Trees {
             cpy.MatchTypeTree(tree)(transform(bound), transform(selector), transformSub(cases))
           case ByNameTypeTree(result) =>
             cpy.ByNameTypeTree(tree)(transform(result))
-          case TypeBoundsTree(lo, hi) =>
-            cpy.TypeBoundsTree(tree)(transform(lo), transform(hi))
+          case TypeBoundsTree(lo, hi, alias) =>
+            cpy.TypeBoundsTree(tree)(transform(lo), transform(hi), transform(alias))
           case Bind(name, body) =>
             cpy.Bind(tree)(name, transform(body))
           case Alternative(trees) =>
@@ -1428,8 +1431,8 @@ object Trees {
               this(this(this(x, bound), selector), cases)
             case ByNameTypeTree(result) =>
               this(x, result)
-            case TypeBoundsTree(lo, hi) =>
-              this(this(x, lo), hi)
+            case TypeBoundsTree(lo, hi, alias) =>
+              this(this(this(x, lo), hi), alias)
             case Bind(name, body) =>
               this(x, body)
             case Alternative(trees) =>

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

@@ -179,8 +179,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def MatchTypeTree(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit ctx: Context): MatchTypeTree =
     ta.assignType(untpd.MatchTypeTree(bound, selector, cases), bound, selector, cases)
 
-  def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree =
-    ta.assignType(untpd.TypeBoundsTree(lo, hi), lo, hi)
+  def TypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(implicit ctx: Context): TypeBoundsTree =
+    ta.assignType(untpd.TypeBoundsTree(lo, hi, alias), lo, hi, alias)
 
   def Bind(sym: Symbol, body: Tree)(implicit ctx: Context): Bind =
     ta.assignType(untpd.Bind(sym.name, body), sym)

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

@@ -376,7 +376,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def LambdaTypeTree(tparams: List[TypeDef], body: Tree)(implicit src: SourceFile): LambdaTypeTree = new LambdaTypeTree(tparams, body)
   def MatchTypeTree(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): MatchTypeTree = new MatchTypeTree(bound, selector, cases)
   def ByNameTypeTree(result: Tree)(implicit src: SourceFile): ByNameTypeTree = new ByNameTypeTree(result)
-  def TypeBoundsTree(lo: Tree, hi: Tree)(implicit src: SourceFile): TypeBoundsTree = new TypeBoundsTree(lo, hi)
+  def TypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(implicit src: SourceFile): TypeBoundsTree = new TypeBoundsTree(lo, hi, alias)
   def Bind(name: Name, body: Tree)(implicit src: SourceFile): Bind = new Bind(name, body)
   def Alternative(trees: List[Tree])(implicit src: SourceFile): Alternative = new Alternative(trees)
   def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree])(implicit src: SourceFile): UnApply = new UnApply(fun, implicits, patterns)

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

@@ -588,11 +588,15 @@ class TreePickler(pickler: TastyPickler) {
         case LambdaTypeTree(tparams, body) =>
           writeByte(LAMBDAtpt)
           withLength { pickleParams(tparams); pickleTree(body) }
-        case TypeBoundsTree(lo, hi) =>
+        case TypeBoundsTree(lo, hi, alias) =>
           writeByte(TYPEBOUNDStpt)
           withLength {
             pickleTree(lo);
-            if (hi ne lo) pickleTree(hi)
+            if alias.isEmpty then
+              if hi ne lo then pickleTree(hi)
+            else
+              pickleTree(hi)
+              pickleTree(alias)
           }
         case Hole(_, idx, args) =>
           writeByte(HOLE)

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

@@ -1209,8 +1209,9 @@ class TreeUnpickler(reader: TastyReader,
               MatchTypeTree(bound, scrut, readCases(end))
             case TYPEBOUNDStpt =>
               val lo = readTpt()
-              val hi = if (currentAddr == end) lo else readTpt()
-              TypeBoundsTree(lo, hi)
+              val hi = if currentAddr == end then lo else readTpt()
+              val alias = if currentAddr == end then EmptyTree else readTpt()
+              TypeBoundsTree(lo, hi, alias)
             case HOLE =>
               readHole(end, isType = false)
             case _ =>

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

@@ -3344,7 +3344,7 @@ object Parsers {
               rhs match {
                 case mtt: MatchTypeTree =>
                   bounds match {
-                    case TypeBoundsTree(EmptyTree, upper) =>
+                    case TypeBoundsTree(EmptyTree, upper, _) =>
                       rhs = MatchTypeTree(upper, mtt.selector, mtt.cases)
                     case _ =>
                       syntaxError(i"cannot combine lower bound and match type alias", eqOffset)
@@ -3568,7 +3568,7 @@ object Parsers {
             DefDef(name, tparams, vparamss, parents.head, subExpr())
           else
             parents match
-              case TypeBoundsTree(_, _) :: _ => syntaxError("`=` expected")
+              case (_: TypeBoundsTree) :: _ => syntaxError("`=` expected")
               case _ =>
             possibleTemplateStart()
             val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))

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

@@ -492,9 +492,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case ByNameTypeTree(tpt) =>
         "=> " ~ toTextLocal(tpt)
-      case TypeBoundsTree(lo, hi) =>
-        if (lo eq hi) optText(lo)(" = " ~ _)
-        else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _)
+      case TypeBoundsTree(lo, hi, alias) =>
+        if (lo eq hi) && alias.isEmpty then optText(lo)(" = " ~ _)
+        else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _) ~ optText(alias)(" = " ~ _)
       case Bind(name, body) =>
         keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
         changePrec(InfixPrec) { toText(name) ~ " @ " ~ toText(body) }

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

@@ -136,7 +136,7 @@ class ReifyQuotes extends MacroTransform {
       def mkTagSymbolAndAssignType(spliced: TermRef): TypeDef = {
         val splicedTree = tpd.ref(spliced).withSpan(expr.span)
         val rhs = transform(splicedTree.select(tpnme.splice))
-        val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs)
+        val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs, EmptyTree)
         val local = ctx.newSymbol(
           owner = ctx.owner,
           name = UniqueName.fresh((splicedTree.symbol.name.toString + "$_").toTermName).toTypeName,

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

@@ -607,8 +607,11 @@ trait TypeAssigner {
   def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context): ByNameTypeTree =
     tree.withType(ExprType(result.tpe))
 
-  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree =
-    tree.withType(if (lo eq hi) TypeAlias(lo.tpe) else TypeBounds(lo.tpe, hi.tpe))
+  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree, alias: Tree)(implicit ctx: Context): TypeBoundsTree =
+    tree.withType(
+      if !alias.isEmpty then alias.tpe
+      else if lo eq hi then TypeAlias(lo.tpe)
+      else TypeBounds(lo.tpe, hi.tpe))
 
   def assignType(tree: untpd.Bind, sym: Symbol)(implicit ctx: Context): Bind =
     tree.withType(NamedType(NoPrefix, sym))

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

@@ -633,7 +633,7 @@ class Typer extends Namer
 
         tpt1 match {
           case AppliedTypeTree(_, targs) =>
-            for (targ @ TypeBoundsTree(_, _) <- targs)
+            for case targ: TypeBoundsTree <- targs do
               ctx.error(WildcardOnTypeArgumentNotAllowedOnNew(), targ.sourcePos)
           case _ =>
         }
@@ -1445,7 +1445,7 @@ class Typer extends Namer
             }
           if (desugaredArg.isType)
             arg match {
-              case TypeBoundsTree(EmptyTree, EmptyTree)
+              case TypeBoundsTree(EmptyTree, EmptyTree, _)
               if tparam.paramInfo.isLambdaSub &&
                  tpt1.tpe.typeParamSymbols.nonEmpty &&
                  !ctx.mode.is(Mode.Pattern) =>
@@ -1464,7 +1464,7 @@ class Typer extends Namer
         args.zipWithConserve(tparams)(typedArg(_, _)).asInstanceOf[List[Tree]]
       }
       val paramBounds = tparams.lazyZip(args).map {
-        case (tparam, TypeBoundsTree(EmptyTree, EmptyTree)) =>
+        case (tparam, TypeBoundsTree(EmptyTree, EmptyTree, _)) =>
           // if type argument is a wildcard, suppress kind checking since
           // there is no real argument.
           NoType
@@ -1507,14 +1507,15 @@ class Typer extends Namer
   }
 
   def typedTypeBoundsTree(tree: untpd.TypeBoundsTree, pt: Type)(implicit ctx: Context): Tree = {
-    val TypeBoundsTree(lo, hi) = tree
+    val TypeBoundsTree(lo, hi, alias) = tree
     val lo1 = typed(lo)
     val hi1 = typed(hi)
+    val alias1 = typed(alias)
 
     val lo2 = if (lo1.isEmpty) typed(untpd.TypeTree(defn.NothingType)) else lo1
     val hi2 = if (hi1.isEmpty) typed(untpd.TypeTree(defn.AnyType)) else hi1
 
-    val tree1 = assignType(cpy.TypeBoundsTree(tree)(lo2, hi2), lo2, hi2)
+    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.
       // The bounds of the type symbol can be constrained when comparing a pattern type