Making EmptyTree a special case of TempTrees

7 files changed, 65 insertions, 67 deletions

diff --git a/src/dotty/tools/dotc/ast/CheckTrees.scala b/src/dotty/tools/dotc/ast/CheckTrees.scala
index 881980d4a..0249c3afa 100644
--- a/src/dotty/tools/dotc/ast/CheckTrees.scala
+++ b/src/dotty/tools/dotc/ast/CheckTrees.scala
@@ -236,7 +236,7 @@ object CheckTrees {
       check(annot.isInstantiation)
       check(annot.symbol.owner.isSubClass(defn.AnnotationClass))
       check(arg.isValueType || arg.isValue)
-    case EmptyTree() =>
+    case EmptyTree =>
     case SharedTree(shared) =>
       check(shared.isType || shared.isTerm)
   }
diff --git a/src/dotty/tools/dotc/ast/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala
index 75e82ecca..2d14e6dab 100644
--- a/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -15,8 +15,8 @@ import util.HashSet
 abstract class TreeInfo {
 
   def isDeclarationOrTypeDef(tree: Tree[_ >: Untyped]): Boolean = tree match {
-    case DefDef(_, _, _, _, _, EmptyTree())
-      | ValDef(_, _, _, EmptyTree())
+    case DefDef(_, _, _, _, _, EmptyTree)
+      | ValDef(_, _, _, EmptyTree)
       | TypeDef(_, _, _, _) => true
     case _ => false
   }
@@ -24,7 +24,7 @@ abstract class TreeInfo {
   /** Is tree legal as a member definition of an interface?
    */
   def isInterfaceMember(tree: Tree[_ >: Untyped]): Boolean = tree match {
-    case EmptyTree() => true
+    case EmptyTree => true
     case Import(_, _) => true
     case TypeDef(_, _, _, _) => true
     case DefDef(mods, _, _, _, _, __) => mods.flags is Deferred
@@ -36,7 +36,7 @@ abstract class TreeInfo {
    *  evaluated as part of a block after the first time?
    */
   def isIdempotentDef(tree: Tree[Type])(implicit ctx: Context): Boolean = tree match {
-    case EmptyTree()
+    case EmptyTree
       | ClassDef(_, _, _, _)
       | TypeDef(_, _, _, _)
       | Import(_, _)
@@ -57,7 +57,7 @@ abstract class TreeInfo {
    *  because the expression result from evaluating them is always the same.
    */
   def isIdempotentExpr(tree: Tree[Type])(implicit ctx: Context): Boolean = tree match {
-    case EmptyTree()
+    case EmptyTree
        | This(_)
        | Super(_, _)
        | Literal(_) =>
@@ -211,7 +211,7 @@ abstract class TreeInfo {
   def firstConstructor[T >: Untyped](stats: List[Tree[T]]): Tree[T] = stats match {
     case (meth: DefDef[_]) :: _ if meth.name.isConstructorName => meth
     case stat :: stats => firstConstructor(stats)
-    case nil => EmptyTree()
+    case nil => emptyTree()
   }
 
   /** The arguments to the first constructor in `stats`. */
@@ -310,14 +310,14 @@ abstract class TreeInfo {
 
   /** Is this pattern node a catch-all (wildcard or variable) pattern? */
   def isDefaultCase(cdef: CaseDef[_ >: Untyped]) = cdef match {
-    case CaseDef(pat, EmptyTree(), _) => isWildcardArg(pat)
+    case CaseDef(pat, EmptyTree, _) => isWildcardArg(pat)
     case _                            => false
   }
 
   /** Is this pattern node a synthetic catch-all case, added during PartialFuction synthesis before we know
     * whether the user provided cases are exhaustive. */
   def isSyntheticDefaultCase(cdef: CaseDef[_ >: Untyped]) = cdef match {
-    case CaseDef(Bind(nme.DEFAULT_CASE, _), EmptyTree(), _) => true
+    case CaseDef(Bind(nme.DEFAULT_CASE, _), EmptyTree, _) => true
     case _                                                  => false
   }
 
@@ -337,9 +337,9 @@ abstract class TreeInfo {
 
   /** Is this pattern node a catch-all or type-test pattern? */
   def isCatchCase(cdef: CaseDef[Type])(implicit ctx: Context) = cdef match {
-    case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree(), _) =>
+    case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) =>
       isSimpleThrowable(tpt.tpe)
-    case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree(), _) =>
+    case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) =>
       isSimpleThrowable(tpt.tpe)
     case _ =>
       isDefaultCase(cdef)
@@ -354,7 +354,7 @@ abstract class TreeInfo {
   }
 
   /** Is this case guarded? */
-  def isGuardedCase(cdef: CaseDef[_ >: Untyped]) = cdef.guard != EmptyTree()
+  def isGuardedCase(cdef: CaseDef[_ >: Untyped]) = cdef.guard ne EmptyTree
 
   /** Is this pattern node a sequence-valued pattern? */
   def isSequenceValued(tree: Tree[_ >: Untyped]): Boolean = unbind(tree) match {
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index f84d32712..a574cfe91 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -219,7 +219,7 @@ object Trees {
 
     /** if this tree is the empty tree, the alternative, else this tree */
     def orElse(that: => Tree[T]): Tree[T] =
-      if (this eq theEmptyTree) that else this
+      if (this eq EmptyTree) that else this
 
     override def toText(printer: Printer) = printer.toText(this)
 
@@ -316,7 +316,7 @@ object Trees {
     extends RefTree[T] {
     type ThisTree[T >: Untyped] = Ident[T]
     def withName(name: Name) = this.derivedIdent(name)
-    def qualifier: Tree[T] = EmptyTree[T]
+    def qualifier: Tree[T] = emptyTree[T]
   }
 
   class BackquotedIdent[T >: Untyped](name: Name)
@@ -441,7 +441,7 @@ object Trees {
    *  After program transformations this is not necessarily the enclosing method, because
    *  closures can intervene.
    */
-  case class Return[T >: Untyped](expr: Tree[T], from: Tree[T] = EmptyTree[T]())
+  case class Return[T >: Untyped](expr: Tree[T], from: Tree[T] = emptyTree[T]())
     extends TermTree[T] {
     type ThisTree[T >: Untyped] = Return[T]
   }
@@ -465,7 +465,7 @@ object Trees {
   }
 
   /** A type tree that represents an existing or inferred type */
-  case class TypeTree[T >: Untyped](original: Tree[T] = EmptyTree[T])
+  case class TypeTree[T >: Untyped](original: Tree[T] = emptyTree[T])
     extends DenotingTree[T] with TypTree[T] {
     type ThisTree[T >: Untyped] = TypeTree[T]
     override def initialPos = NoPosition
@@ -606,20 +606,12 @@ object Trees {
     override def isEmpty: Boolean = true
   }
 
-  /** A missing tree */
-  abstract case class EmptyTree[T >: Untyped]()
-    extends Tree[T] with AlwaysEmpty[T] {
-    type ThisTree[T >: Untyped] = EmptyTree[T]
-  }
-
-  private object theEmptyTree extends EmptyTree[Untyped]
+  val EmptyTree: TempTrees[_] = TempTrees(Array[Tree[Untyped]]())
 
-  object EmptyTree {
-    def apply[T >: Untyped](): EmptyTree[T] = theEmptyTree.asInstanceOf[EmptyTree[T]]
-  }
+  def emptyTree[T >: Untyped](): TempTrees[T] = EmptyTree.asInstanceOf[TempTrees[T]]
 
   class EmptyValDef[T >: Untyped] extends ValDef[T](
-    Modifiers[T](Private), nme.WILDCARD, EmptyTree[T], EmptyTree[T]) with AlwaysEmpty[T]
+    Modifiers[T](Private), nme.WILDCARD, emptyTree[T], emptyTree[T]) with AlwaysEmpty[T]
 
   private object theEmptyValDef extends EmptyValDef[Untyped]
 
@@ -646,6 +638,7 @@ object Trees {
 
     type ThisTree[T >: Untyped] = TempTrees[T]
     override def tpe: T = unsupported("tpe")
+    override def withType(tpe: Type) = unsupported("withType")
 
     def apply(i: Int): Tree[T] = trees(i)
     def length: Int = trees.length
@@ -697,6 +690,10 @@ object Trees {
   }
 
   object TempTrees {
+    def apply[T >: Untyped](): Tree[T] = emptyTree()
+    def apply[T >: Untyped](x1: Tree[T], x2: Tree[T]): TempTrees[T] = TempTrees(Array[Tree[T]](x1, x2))
+    def apply[T >: Untyped](x1: Tree[T], x2: Tree[T], x3: Tree[T]): TempTrees[T] = TempTrees(Array[Tree[T]](x1, x2, x3))
+
     def fromList[T >: Untyped](elems: List[Tree[T]]): TempTrees[T] = apply(elems.toArray)
   }
 
@@ -796,7 +793,6 @@ object Trees {
     type Import = Trees.Import[T]
     type PackageDef = Trees.PackageDef[T]
     type Annotated = Trees.Annotated[T]
-    type EmptyTree = Trees.EmptyTree[T]
     type SharedTree = Trees.SharedTree[T]
     type TempTrees = Trees.TempTrees[T]
 
@@ -805,7 +801,7 @@ object Trees {
     def defPos(sym: Symbol)(implicit ctx: Context) = ctx.position union sym.coord.toPosition
 
     def Parameter(pname: TermName, tpe: Tree, mods: Modifiers = Modifiers()): ValDef =
-      ValDef(mods | Param, pname, tpe, EmptyTree())
+      ValDef(mods | Param, pname, tpe, emptyTree())
   }
 
   // ----- Helper functions and classes ---------------------------------------
@@ -1064,7 +1060,7 @@ object Trees {
         finishPackageDef(tree.derivedPackageDef(transformSub(pid, c), transform(stats, c)), tree, c, plugins)
       case Annotated(annot, arg) =>
         finishAnnotated(tree.derivedAnnotated(transform(annot, c), transform(arg, c)), tree, c, plugins)
-      case EmptyTree() =>
+      case EmptyTree =>
         finishEmptyTree(tree, tree, c, plugins)
       case tree @ SharedTree(shared) =>
         finishSharedTree(
@@ -1216,7 +1212,7 @@ object Trees {
         tree.derivedPackageDef(transformSub(pid), transform(stats))
       case Annotated(annot, arg) =>
         tree.derivedAnnotated(transform(annot), transform(arg))
-      case EmptyTree() =>
+      case EmptyTree =>
         tree
       case tree @ SharedTree(shared) =>
         sharedMemo get tree match {
@@ -1322,7 +1318,7 @@ object Trees {
         this(this(x, pid), stats)
       case Annotated(annot, arg) =>
         this(this(x, annot), arg)
-      case EmptyTree() =>
+      case EmptyTree =>
         x
       case tree @ SharedTree(shared) =>
         sharedMemo get tree match {
diff --git a/src/dotty/tools/dotc/ast/TypedTrees.scala b/src/dotty/tools/dotc/ast/TypedTrees.scala
index c46da61f2..ba5d99406 100644
--- a/src/dotty/tools/dotc/ast/TypedTrees.scala
+++ b/src/dotty/tools/dotc/ast/TypedTrees.scala
@@ -244,7 +244,7 @@ object tpd extends Trees.Instance[Type] {
   def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated =
     Trees.Annotated(annot, arg).withType(AnnotatedType(Annotation(annot), arg.tpe)).checked
 
-  val EmptyTree: Tree = Trees.EmptyTree[Type]
+  val EmptyTree: Tree = emptyTree[Type]()
 
   val EmptyValDef: ValDef = Trees.EmptyValDef[Type]
 
diff --git a/src/dotty/tools/dotc/ast/UntypedTrees.scala b/src/dotty/tools/dotc/ast/UntypedTrees.scala
index 8f9ef59e1..4f9df1533 100644
--- a/src/dotty/tools/dotc/ast/UntypedTrees.scala
+++ b/src/dotty/tools/dotc/ast/UntypedTrees.scala
@@ -12,6 +12,8 @@ import collection.mutable.ListBuffer
 
 object untpd extends Trees.Instance[Untyped] {
 
+  val EmptyTree = emptyTree[Untyped]()
+
 // ----- Tree cases that exist in untyped form only ------------------
 
   /** A typed subtree of an untyped tree needs to be wrapped in a TypedSlice */
@@ -52,11 +54,11 @@ object untpd extends Trees.Instance[Untyped] {
 
   def scalaUnit(implicit ctx: Context) = ref(defn.UnitClass.typeConstructor)
 
-  def makeConstructor(mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree = EmptyTree())(implicit ctx: Context): DefDef =
+  def makeConstructor(mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef =
     DefDef(mods, nme.CONSTRUCTOR, Nil, vparamss, TypeTree(), rhs)
 
   def makeSelfDef(name: TermName, tpt: Tree)(implicit ctx: Context) =
-    ValDef(Modifiers(Private), name, tpt, EmptyTree())
+    ValDef(Modifiers(Private), name, tpt, EmptyTree)
 
   def makeTupleOrParens(ts: List[Tree])(implicit ctx: Context) = ts match {
     case t :: Nil => Parens(t)
@@ -73,7 +75,7 @@ object untpd extends Trees.Instance[Untyped] {
   def desugar(tree: Tree, mode: Mode.Value)(implicit ctx: Context): Tree = {
 
     def makeSyntheticParameter(): ValDef =
-      ValDef(Modifiers(SyntheticTermParam), ctx.freshName().toTermName, TypeTree(), EmptyTree())
+      ValDef(Modifiers(SyntheticTermParam), ctx.freshName().toTermName, TypeTree(), EmptyTree)
 
     def labelDefAndCall(lname: TermName, rhs: Tree, call: Tree) = {
       val ldef = DefDef(Modifiers(Label), lname, Nil, ListOfNil, TypeTree(), rhs)
@@ -108,7 +110,7 @@ object untpd extends Trees.Instance[Untyped] {
     /** Make closure corresponding to function  params => body */
     def makeClosure(params: List[ValDef], body: Tree) =
       Block(
-        DefDef(Modifiers(Synthetic), nme.ANON_FUN, Nil, params :: Nil, EmptyTree(), body),
+        DefDef(Modifiers(Synthetic), nme.ANON_FUN, Nil, params :: Nil, EmptyTree, body),
         Closure(Nil, Ident(nme.ANON_FUN)))
 
     /** Make closure corresponding to partial function  { cases } */
@@ -173,9 +175,9 @@ object untpd extends Trees.Instance[Untyped] {
        */
       def makeLambda(pat: Tree, body: Tree): Tree = pat match {
         case VarPattern(named, tpt) =>
-          makeClosure(derivedValDef(Modifiers(Param), named, tpt, EmptyTree()) :: Nil, body)
+          makeClosure(derivedValDef(Modifiers(Param), named, tpt, EmptyTree) :: Nil, body)
         case _ =>
-          makeCaseClosure(CaseDef(pat, EmptyTree(), body) :: Nil)
+          makeCaseClosure(CaseDef(pat, EmptyTree, body) :: Nil)
       }
 
       /** If `pat` is not yet a `Bind` wrap it in one with a fresh name
@@ -213,9 +215,9 @@ object untpd extends Trees.Instance[Untyped] {
        */
       def makePatFilter(rhs: Tree, pat: Tree): Tree = {
         val cases = List(
-          CaseDef(pat, EmptyTree(), Literal(Constant(true))),
-          CaseDef(Ident(nme.WILDCARD), EmptyTree(), Literal(Constant(false))))
-        Apply(Select(rhs, nme.withFilterIfRefutable), Match(EmptyTree(), cases))
+          CaseDef(pat, EmptyTree, Literal(Constant(true))),
+          CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(Constant(false))))
+        Apply(Select(rhs, nme.withFilterIfRefutable), Match(EmptyTree, cases))
       }
 
       /** rhs.name with a pattern filter on rhs unless `pat` is irrefutable when
@@ -248,7 +250,7 @@ object untpd extends Trees.Instance[Untyped] {
           val filtered = Apply(rhsSelect(rhs, nme.withFilter, pat), makeLambda(pat, test))
           makeFor(mapName, flatMapName, GenFrom(pat, filtered) :: rest, body)
         case _ =>
-          EmptyTree() //may happen for erroneous input
+          EmptyTree //may happen for erroneous input
       }
     }
 
@@ -279,7 +281,7 @@ object untpd extends Trees.Instance[Untyped] {
         val rhsUnchecked = makeAnnotated(defn.UncheckedAnnot, rhs)
         val vars = getVariables(pat)
         val ids = for ((named, _) <- vars) yield Ident(named.name)
-        val caseDef = CaseDef(pat, EmptyTree(), makeTuple(ids))
+        val caseDef = CaseDef(pat, EmptyTree, makeTuple(ids))
         val matchExpr = Match(rhsUnchecked, caseDef :: Nil)
         vars match {
           case (named, tpt) :: Nil =>
@@ -309,9 +311,9 @@ object untpd extends Trees.Instance[Untyped] {
         desugarAnonClass(templ)
       case Assign(Apply(fn, args), rhs) =>
         Apply(Select(fn, nme.update), args :+ rhs)
-      case If(cond, thenp, EmptyTree()) =>
+      case If(cond, thenp, EmptyTree) =>
         If(cond, thenp, unitLiteral)
-      case Match(EmptyTree(), cases) =>
+      case Match(EmptyTree, cases) =>
         makeCaseClosure(cases)
       case _: DefDef | _: ClassDef =>
         desugarContextBounds(tree)
@@ -401,7 +403,7 @@ object untpd extends Trees.Instance[Untyped] {
           val accessMods = if (ofClass) PrivateOrLocal else EmptyFlags
           val epname = (nme.EVIDENCE_PARAM_PREFIX.toString + epbuf.length).toTermName
           epbuf +=
-            ValDef(Modifiers(Implicit | Param | accessMods), epname, cxbound, EmptyTree())
+            ValDef(Modifiers(Implicit | Param | accessMods), epname, cxbound, EmptyTree)
         }
         tparam.derivedTypeDef(mods, name, ttparams, tbounds)
       case tparam =>
diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index 645929a6b..f89eeff8f 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -566,7 +566,7 @@ object Parsers {
             else expr()
           else {
             syntaxErrorOrIncomplete("error in interpolated string: identifier or block expected")
-            EmptyTree()
+            EmptyTree
           }
         }
       }
@@ -680,7 +680,7 @@ object Parsers {
       if (in.token == LPAREN)
         atPos(in.offset) { makeTupleOrParens(inParens(argTypes())) }
       else if (in.token == LBRACE)
-        atPos(in.offset) { RefinedTypeTree(EmptyTree(), refinement()) }
+        atPos(in.offset) { RefinedTypeTree(EmptyTree, refinement()) }
       else path(thisOK = false, handleSingletonType) match {
         case r @ SingletonTypeTree(_) => r
         case r => convertToTypeId(r)
@@ -751,7 +751,7 @@ object Parsers {
 
     private def bound(tok: Int): Tree =
       if (in.token == tok) { in.nextToken(); typ() }
-      else EmptyTree()
+      else EmptyTree
 
     /** TypeParamBounds   ::=  TypeBounds {`<%' Type} {`:' Type}
      */
@@ -851,7 +851,7 @@ object Parsers {
           newLinesOpt()
           val thenp = expr()
           val elsep = if (in.token == ELSE) { in.nextToken(); expr() }
-                      else EmptyTree()
+                      else EmptyTree
           If(cond, thenp, elsep)
         }
       case WHILE =>
@@ -876,16 +876,16 @@ object Parsers {
             if (in.token == CATCH) {
               in.nextToken()
               expr()
-            } else EmptyTree()
+            } else EmptyTree
           val finalizer =
             if (handler.isEmpty || in.token == FINALLY) { accept(FINALLY); expr() }
-            else EmptyTree()
+            else EmptyTree
           Try(body, handler, finalizer)
         }
       case THROW =>
         atPos(in.skipToken()) { Throw(expr()) }
       case RETURN =>
-        atPos(in.skipToken()) { Return(if (isExprIntro) expr() else EmptyTree(), EmptyTree()) }
+        atPos(in.skipToken()) { Return(if (isExprIntro) expr() else EmptyTree, EmptyTree) }
       case FOR =>
         forExpr()
       case IMPLICIT =>
@@ -1071,7 +1071,7 @@ object Parsers {
      */
     def blockExpr(): Tree = atPos(in.offset) {
       inDefScopeBraces {
-        if (in.token == CASE) Match(EmptyTree(), caseClauses())
+        if (in.token == CASE) Match(EmptyTree, caseClauses())
         else block()
       }
     }
@@ -1082,14 +1082,14 @@ object Parsers {
     def block(): Tree = {
       val stats = blockStatSeq()
       if (stats.nonEmpty && stats.last.isTerm) Block(stats.init, stats.last)
-      else Block(stats, EmptyTree())
+      else Block(stats, EmptyTree)
     }
 
     /** Guard ::= if PostfixExpr
      */
     def guard(): Tree =
       if (in.token == IF) { in.nextToken(); postfixExpr() }
-      else EmptyTree()
+      else EmptyTree
 
     /** Enumerators ::= Generator {semi Enumerator | Guard}
      */
@@ -1488,7 +1488,7 @@ object Parsers {
             }
           val default =
             if (in.token == EQUALS) { in.nextToken(); expr() }
-            else EmptyTree()
+            else EmptyTree
           if (implicitOffset >= 0) {
             mods = mods.withPos(mods.pos.withStart(implicitOffset))
             implicitOffset = -1
@@ -1628,7 +1628,7 @@ object Parsers {
           } else {
             expr()
           }
-        } else EmptyTree()
+        } else EmptyTree
       lhs match {
         case (id @ Ident(name: TermName)) :: Nil => id.derivedValDef(mods, name, tpt, rhs)
         case _ => PatDef(mods, lhs, tpt, rhs)
@@ -1661,7 +1661,7 @@ object Parsers {
         var restype = fromWithinReturnType(typedOpt())
         newLineOptWhenFollowedBy(LBRACE)
         val rhs =
-          if (isStatSep || in.token == RBRACE) EmptyTree()
+          if (isStatSep || in.token == RBRACE) EmptyTree
           else if (restype.isEmpty && in.token == LBRACE) {
             restype = atPos(in.offset) { scalaUnit }
             blockExpr()
@@ -1715,7 +1715,7 @@ object Parsers {
             TypeDef(mods, name, tparams, typeBounds())
           case _ =>
             syntaxErrorOrIncomplete("`=', `>:', or `<:' expected")
-            EmptyTree()
+            EmptyTree
         }
       }
     }
@@ -1736,7 +1736,7 @@ object Parsers {
           objectDef(posMods(start, mods | Case | Module))
         case _ =>
           syntaxErrorOrIncomplete("expected start of definition")
-          EmptyTree()
+          EmptyTree
     }
 
     /** ClassDef ::= Id [ClsTypeParamClause]
@@ -1919,7 +1919,7 @@ object Parsers {
         }
         acceptStatSepUnlessAtEnd()
       }
-      (self, if (stats.isEmpty) List(EmptyTree()) else stats.toList)
+      (self, if (stats.isEmpty) List(EmptyTree) else stats.toList)
     }
 
     /** RefineStatSeq    ::= RefineStat {semi RefineStat}
@@ -2048,8 +2048,8 @@ object Parsers {
       body
     }
 
-    override def blockExpr(): Tree = skipBraces(EmptyTree())
+    override def blockExpr(): Tree = skipBraces(EmptyTree)
 
-    override def templateBody() = skipBraces((EmptyValDef(), List(EmptyTree())))
+    override def templateBody() = skipBraces((EmptyValDef(), List(EmptyTree)))
   }
 }
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 2fd3bf9fe..9a3baa03f 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -16,7 +16,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected val PrintableFlags = (ModifierFlags | Label | Module).toCommonFlags
 
   /** The closest enclosing DefDef, TypeDef, or ClassDef node */
-  private var currentOwner: Tree[_ >: Untyped] = EmptyTree()
+  private var currentOwner: Tree[_ >: Untyped] = emptyTree()
 
   def atOwner(owner: Tree[_ >: Untyped])(op: => Text): Text = {
     val saved = owner
@@ -262,7 +262,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "package " ~ toTextLocal(pid) ~ bodyText
       case Annotated(annot, arg) =>
         toTextLocal(arg) ~~ annotText(annot)
-      case EmptyTree() =>
+      case EmptyTree =>
         "<empty>"
       case SharedTree(shared) =>
         toText(shared)