Refactor Tree parameterization

Refactor `Tree` parameterization to make use of -Yexplicit-nulls.

We now have:

```scala
   type Untyped = Type | Null
   abstract class Tree[+T <: Untyped]
   object untpd:
     type Tree = Tree[Untyped]
   object tpe:
     type Tree = Tree[Type]
```

Author: odersky

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

@@ -14,7 +14,7 @@ import scala.collection.mutable
 
 import scala.annotation.tailrec
 
-trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
+trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
 
   // Note: the <: Type constraint looks necessary (and is needed to make the file compile in dotc).
   // But Scalac accepts the program happily without it. Need to find out why.

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

@@ -42,7 +42,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   /** mods object name impl */
   case class ModuleDef(name: TermName, impl: Template)(implicit @constructorOnly src: SourceFile)
     extends MemberDef {
-    type ThisTree[-T >: Untyped] <: Trees.NameTree[T] with Trees.MemberDef[T] with ModuleDef
+    type ThisTree[+T <: Untyped] <: Trees.NameTree[T] with Trees.MemberDef[T] with ModuleDef
     def withName(name: Name)(using Context): ModuleDef = cpy.ModuleDef(this)(name.toTermName, impl)
   }
 

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

@@ -156,9 +156,9 @@ object Contexts {
     final def owner: Symbol = _owner
 
     /** The current tree */
-    private var _tree: Tree[? >: Untyped]= _
-    protected def tree_=(tree: Tree[? >: Untyped]): Unit = _tree = tree
-    final def tree: Tree[? >: Untyped] = _tree
+    private var _tree: Tree[? <: Untyped]= _
+    protected def tree_=(tree: Tree[? <: Untyped]): Unit = _tree = tree
+    final def tree: Tree[? <: Untyped] = _tree
 
     /** The current scope */
     private var _scope: Scope = _
@@ -469,7 +469,7 @@ object Contexts {
     }
 
     /** The context of expression `expr` seen as a member of a statement sequence */
-    def exprContext(stat: Tree[? >: Untyped], exprOwner: Symbol): Context =
+    def exprContext(stat: Tree[? <: Untyped], exprOwner: Symbol): Context =
       if (exprOwner == this.owner) this
       else if (untpd.isSuperConstrCall(stat) && this.owner.isClass) superCallContext
       else fresh.setOwner(exprOwner)
@@ -592,7 +592,7 @@ object Contexts {
       assert(owner != NoSymbol)
       this.owner = owner
       this
-    def setTree(tree: Tree[? >: Untyped]): this.type =
+    def setTree(tree: Tree[? <: Untyped]): this.type =
       util.Stats.record("Context.setTree")
       this.tree = tree
       this

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

@@ -745,16 +745,6 @@ object Types {
           // which means that we always defensively copy the type in the future. This second
           // measure is necessary because findMember calls might be cached, so do not
           // necessarily appear in nested order.
-          // Without the defensive copy, Typer.scala fails to compile at the line
-          //
-          //      untpd.rename(lhsCore, setterName).withType(setterType), WildcardType)
-          //
-          // because the subtype check
-          //
-          //      ThisTree[Untyped]#ThisTree[Typed] <: Tree[Typed]
-          //
-          // fails (in fact it thinks the underlying type of the LHS is `Tree[Untyped]`.)
-          //
           // Without the `openedTwice` trick, Typer.scala fails to Ycheck
           // at phase resolveSuper.
           val rt =

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

@@ -607,7 +607,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
   def toText(sc: Scope): Text =
     ("Scope{" ~ dclsText(sc.toList) ~ "}").close
 
-  def toText[T >: Untyped](tree: Tree[T]): Text = {
+  def toText[T <: Untyped](tree: Tree[T]): Text = {
     def toTextElem(elem: Any): Text = elem match {
       case elem: Showable => elem.toText(this)
       case elem: List[?] => "List(" ~ Text(elem map toTextElem, ",") ~ ")"

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

@@ -149,7 +149,7 @@ abstract class Printer {
   def toText(sc: Scope): Text
 
   /** Textual representation of tree */
-  def toText[T >: Untyped](tree: Tree[T]): Text
+  def toText[T <: Untyped](tree: Tree[T]): Text
 
   /** Textual representation of source position */
   def toText(pos: SourcePosition): Text

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

@@ -40,7 +40,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   override def printerContext: Context = myCtx
 
-  def withEnclosingDef(enclDef: Tree[? >: Untyped])(op: => Text): Text = {
+  def withEnclosingDef(enclDef: Tree[? <: Untyped])(op: => Text): Text = {
     val savedCtx = myCtx
     if (enclDef.hasType && enclDef.symbol.exists)
       myCtx = ctx.withOwner(enclDef.symbol)
@@ -308,15 +308,15 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def exprToText(tp: ExprType): Text =
     "=> " ~ toText(tp.resType)
 
-  protected def blockToText[T >: Untyped](block: Block[T]): Text =
+  protected def blockToText[T <: Untyped](block: Block[T]): Text =
     blockText(block.stats :+ block.expr)
 
-  protected def blockText[T >: Untyped](trees: List[Tree[T]]): Text =
+  protected def blockText[T <: Untyped](trees: List[Tree[T]]): Text =
     inContextBracket {
       ("{" ~ toText(trees, "\n") ~ "}").close
     }
 
-  protected def typeApplyText[T >: Untyped](tree: TypeApply[T]): Text = {
+  protected def typeApplyText[T <: Untyped](tree: TypeApply[T]): Text = {
     val funText = toTextLocal(tree.fun)
     tree.fun match {
       case Select(New(tpt), nme.CONSTRUCTOR) if tpt.typeOpt.dealias.isInstanceOf[AppliedType] =>
@@ -326,7 +326,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
   }
 
-  protected def toTextCore[T >: Untyped](tree: Tree[T]): Text = {
+  protected def toTextCore[T <: Untyped](tree: Tree[T]): Text = {
     import untpd._
 
     def isLocalThis(tree: Tree) = tree.typeOpt match {
@@ -739,7 +739,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
   }
 
-  override def toText[T >: Untyped](tree: Tree[T]): Text = controlled {
+  override def toText[T <: Untyped](tree: Tree[T]): Text = controlled {
     import untpd._
 
     var txt = toTextCore(tree)
@@ -826,7 +826,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   protected def dropAnnotForModText(sym: Symbol): Boolean = sym == defn.BodyAnnot
 
-  protected def optAscription[T >: Untyped](tpt: Tree[T]): Text = optText(tpt)(": " ~ _)
+  protected def optAscription[T <: Untyped](tpt: Tree[T]): Text = optText(tpt)(": " ~ _)
 
   private def idText(tree: untpd.Tree): Text =
     (if showUniqueIds && tree.hasType && tree.symbol.exists then s"#${tree.symbol.id}" else "") ~
@@ -842,7 +842,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private def useSymbol(tree: untpd.Tree) =
     tree.hasType && tree.symbol.exists && ctx.settings.YprintSyms.value
 
-  protected def nameIdText[T >: Untyped](tree: NameTree[T]): Text =
+  protected def nameIdText[T <: Untyped](tree: NameTree[T]): Text =
     if (tree.hasType && tree.symbol.exists) {
       val str = nameString(tree.symbol)
       tree match {
@@ -856,13 +856,13 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private def toTextOwner(tree: Tree[?]) =
     "[owner = " ~ tree.symbol.maybeOwner.show ~ "]" provided ctx.settings.YprintDebugOwners.value
 
-  protected def dclTextOr[T >: Untyped](tree: Tree[T])(treeText: => Text): Text =
+  protected def dclTextOr[T <: Untyped](tree: Tree[T])(treeText: => Text): Text =
     toTextOwner(tree) ~ {
       if (useSymbol(tree)) annotsText(tree.symbol) ~~ dclText(tree.symbol)
       else treeText
     }
 
-  def paramsText[T>: Untyped](params: ParamClause[T]): Text = (params: @unchecked) match
+  def paramsText[T <: Untyped](params: ParamClause[T]): Text = (params: @unchecked) match
     case Nil =>
       "()"
     case untpd.ValDefs(vparams @ (vparam :: _)) =>
@@ -872,18 +872,18 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     case untpd.TypeDefs(tparams) =>
       "[" ~ toText(tparams, ", ") ~ "]"
 
-  def addParamssText[T >: Untyped](leading: Text, paramss: List[ParamClause[T]]): Text =
+  def addParamssText[T <: Untyped](leading: Text, paramss: List[ParamClause[T]]): Text =
     paramss.foldLeft(leading)((txt, params) => txt ~ paramsText(params))
 
-  protected def valDefToText[T >: Untyped](tree: ValDef[T]): Text = {
+  protected def valDefToText[T <: Untyped](tree: ValDef[T]): Text = {
     dclTextOr(tree) {
       modText(tree.mods, tree.symbol, keywordStr(if (tree.mods.is(Mutable)) "var" else "val"), isType = false) ~~
         valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
         withEnclosingDef(tree) { optText(tree.rhs)(" = " ~ _) }
     }
   }
 
-  protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
+  protected def defDefToText[T <: Untyped](tree: DefDef[T]): Text = {
     import untpd._
     dclTextOr(tree) {
       val defKeyword = modText(tree.mods, tree.symbol, keywordStr("def"), isType = false)
@@ -989,7 +989,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     )
   }
 
-  protected def toTextPackageId[T >: Untyped](pid: Tree[T]): Text =
+  protected def toTextPackageId[T <: Untyped](pid: Tree[T]): Text =
     if (homogenizedView && pid.hasType) toTextLocal(pid.tpe.asInstanceOf[Showable])
     else toTextLocal(pid)
 
@@ -1044,10 +1044,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   def optText(name: Name)(encl: Text => Text): Text =
     if (name.isEmpty) "" else encl(toText(name))
 
-  def optText[T >: Untyped](tree: Tree[T])(encl: Text => Text): Text =
+  def optText[T <: Untyped](tree: Tree[T])(encl: Text => Text): Text =
     if (tree.isEmpty) "" else encl(toText(tree))
 
-  def optText[T >: Untyped](tree: List[Tree[T]])(encl: Text => Text): Text =
+  def optText[T <: Untyped](tree: List[Tree[T]])(encl: Text => Text): Text =
     if (tree.exists(!_.isEmpty)) encl(blockText(tree)) else ""
 
   override protected def treatAsTypeParam(sym: Symbol): Boolean = sym.is(TypeParam)

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

@@ -614,7 +614,7 @@ object Erasure {
      *  are handled separately by [[typedDefDef]], [[typedValDef]] and [[typedTyped]].
      */
     override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): TypeTree =
-      checkNotErasedClass(tree.withType(erasure(tree.tpe)))
+      checkNotErasedClass(tree.withType(erasure(tree.typeOpt)))
 
     /** This override is only needed to semi-erase type ascriptions */
     override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree =

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

@@ -65,7 +65,7 @@ class InterceptedMethods extends MiniPhase {
   override def transformApply(tree: Apply)(using Context): Tree = {
     lazy val qual = tree.fun match {
       case Select(qual, _) => qual
-      case ident @ Ident(_) =>
+      case ident: Ident =>
         ident.tpe match {
           case TermRef(prefix: TermRef, _) =>
             tpd.ref(prefix)