Splitting creation methods out between tpd and untpd.

Partial revert of previous two commits. Creation methods are no longer implemented on Instance, but separately in untpd and tpd. It turned out that tree copying should not use typed creation methods (would tie in too many things into one complex knot). So there was no generic (between typed/untyped) usage of creation methods left. In that case it seemd better to implement the methods separately in tpd and untpd. That way, we do not need to carry a useless context in untpd methods and we do not need to block unavailable methods in tpd with "unsupported".

3 files changed, 189 insertions, 206 deletions

diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 5836b0863..74f792220 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -717,80 +717,20 @@ object Trees {
     type SharedTree = Trees.SharedTree[T]
     type Thicket = Trees.Thicket[T]
 
-    def Ident(name: Name)(implicit ctx: Context): Ident = new Ident(name)
-    def BackquotedIdent(name: Name)(implicit ctx: Context): BackquotedIdent = new BackquotedIdent(name)
-    def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select = new Select(qualifier, name)
-    def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit ctx: Context): Select = new SelectWithSig(qualifier, name, sig)
-    def This(qual: TypeName)(implicit ctx: Context): This = new This(qual)
-    def Super(qual: Tree, mix: TypeName)(implicit ctx: Context): Super = new Super(qual, mix)
-    def Apply(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = new Apply(fun, args)
-    def TypeApply(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = new TypeApply(fun, args)
-    def Literal(const: Constant)(implicit ctx: Context): Literal = new Literal(const)
-    def New(tpt: Tree)(implicit ctx: Context): New = new New(tpt)
-    def Pair(left: Tree, right: Tree)(implicit ctx: Context): Pair = new Pair(left, right)
-    def Typed(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed = new Typed(expr, tpt)
-    def NamedArg(name: Name, arg: Tree)(implicit ctx: Context): NamedArg = new NamedArg(name, arg)
-    def Assign(lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign = new Assign(lhs, rhs)
-    def Block(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block = new Block(stats, expr)
-    def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = new If(cond, thenp, elsep)
-    def Closure(env: List[Tree], meth: RefTree)(implicit ctx: Context): Closure = new Closure(env, meth)
-    def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = new Match(selector, cases)
-    def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = new CaseDef(pat, guard, body)
-    def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return = new Return(expr, from)
-    def Try(expr: Tree, handler: Tree, finalizer: Tree)(implicit ctx: Context): Try = new Try(expr, handler, finalizer)
-    def Throw(expr: Tree)(implicit ctx: Context): Throw = new Throw(expr)
-    def SeqLiteral(elems: List[Tree])(implicit ctx: Context): SeqLiteral = new SeqLiteral(elems)
-    def TypeTree(original: Tree)(implicit ctx: Context): TypeTree = new TypeTree(original)
-    def TypeTree() = new TypeTree(EmptyTree)
-    def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree = new SingletonTypeTree(ref)
-    def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree = new SelectFromTypeTree(qualifier, name)
-    def AndTypeTree(left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree = new AndTypeTree(left, right)
-    def OrTypeTree(left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree = new OrTypeTree(left, right)
-    def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit ctx: Context): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
-    def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree = new AppliedTypeTree(tpt, args)
-    def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree = new TypeBoundsTree(lo, hi)
-    def Bind(name: Name, body: Tree)(implicit ctx: Context): Bind = new Bind(name, body)
-    def Alternative(trees: List[Tree])(implicit ctx: Context): Alternative = new Alternative(trees)
-    def UnApply(fun: Tree, args: List[Tree])(implicit ctx: Context): UnApply = new UnApply(fun, args)
-    def ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree)(implicit ctx: Context): ValDef = new ValDef(mods, name, tpt, rhs)
-    def DefDef(mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree)(implicit ctx: Context): DefDef = new DefDef(mods, name, tparams, vparamss, tpt, rhs)
-    def TypeDef(mods: Modifiers, name: TypeName, rhs: Tree)(implicit ctx: Context): TypeDef = new TypeDef(mods, name, rhs)
-    def Template(constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree])(implicit ctx: Context): Template = new Template(constr, parents, self, body)
-    def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = new Import(expr, selectors)
-    def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef = new PackageDef(pid, stats)
-    def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated = new Annotated(annot, arg)
-    def SharedTree(shared: Tree)(implicit ctx: Context): SharedTree = new SharedTree(shared)
-    def Thicket(trees: List[Tree])(implicit ctx: Context): Thicket = new Thicket(trees)
-
     val EmptyTree: Thicket = genericEmptyTree
     val EmptyValDef: ValDef = genericEmptyValDef
 
+    // ----- Auxiliary creation methods ------------------
+
     def Modifiers(flags: FlagSet = EmptyFlags,
                   privateWithin: TypeName = tpnme.EMPTY,
                   annotations: List[Tree] = Nil) = new Modifiers(flags, privateWithin, annotations)
 
-    // ----- Auxiliary creation methods ------------------
-
-    // def TypeTree(tpe: Type): TypeTree = TypeTree().withType(tpe) todo: move to untpd/tpd
-
-    /** new tpt(args1)...(args_n)
-     */
-    def New(tpt: Tree, argss: List[List[Tree]])(implicit ctx: Context): Tree =
-      ((Select(New(tpt), nme.CONSTRUCTOR): Tree) /: argss)(Apply(_, _))
-
-    def Block(stat: Tree, expr: Tree)(implicit ctx: Context): Block =
-      Block(stat :: Nil, expr)
-
-    def Apply(fn: Tree, arg: Tree)(implicit ctx: Context): Apply =
-      Apply(fn, arg :: Nil)
-
-    def AppliedTypeTree(tpt: Tree, arg: Tree)(implicit ctx: Context): AppliedTypeTree =
-      AppliedTypeTree(tpt, arg :: Nil)
-
-    def Thicket()(implicit ctx: Context): Thicket = EmptyTree
-    def Thicket(x1: Tree, x2: Tree)(implicit ctx: Context): Thicket = Thicket(x1 :: x2 :: Nil)
-    def Thicket(x1: Tree, x2: Tree, x3: Tree)(implicit ctx: Context): Thicket = Thicket(x1 :: x2 :: x3 :: Nil)
-    def flatTree(xs: List[Tree])(implicit ctx: Context): Tree = flatten(xs) match {
+    def Thicket(trees: List[Tree]): Thicket = new Thicket(trees)
+    def Thicket(): Thicket = EmptyTree
+    def Thicket(x1: Tree, x2: Tree): Thicket = Thicket(x1 :: x2 :: Nil)
+    def Thicket(x1: Tree, x2: Tree, x3: Tree): Thicket = Thicket(x1 :: x2 :: x3 :: Nil)
+    def flatTree(xs: List[Tree]): Tree = flatten(xs) match {
       case x :: Nil => x
       case _ => Thicket(xs)
     }
@@ -845,169 +785,169 @@ object Trees {
       private def copyAttrs(t: untpd.Tree, tree: Tree): t.ThisTree[T] =
         t.withType(tree.typeOpt).withPos(tree.pos).asInstanceOf[t.ThisTree[T]]
 
-      def Ident(tree: Tree, name: Name)(implicit ctx: Context): Ident = tree match {
+      def Ident(tree: Tree, name: Name): Ident = tree match {
         case tree: BackquotedIdent =>
           if (name == tree.name) tree
           else finalize(tree, new BackquotedIdent(name))
         case tree: Ident if (name == tree.name) => tree
         case _ => finalize(tree, untpd.Ident(name))
       }
-      def Select(tree: Tree, qualifier: Tree, name: Name)(implicit ctx: Context): Select = tree match {
+      def Select(tree: Tree, qualifier: Tree, name: Name): Select = tree match {
         case tree: SelectWithSig =>
           if ((qualifier eq tree.qualifier) && (name == tree.name) ) tree
           else finalize(tree, new SelectWithSig(qualifier, name, tree.sig))
         case tree: Select if (qualifier eq tree.qualifier) && (name == tree.name) => tree
         case _ => finalize(tree, untpd.Select(qualifier, name))
       }
-      def This(tree: Tree, qual: TypeName)(implicit ctx: Context): This = tree match {
+      def This(tree: Tree, qual: TypeName): This = tree match {
         case tree: This if (qual == tree.qual) => tree
         case _ => finalize(tree, untpd.This(qual))
       }
-      def Super(tree: Tree, qual: Tree, mix: TypeName)(implicit ctx: Context): Super = tree match {
+      def Super(tree: Tree, qual: Tree, mix: TypeName): Super = tree match {
         case tree: Super if (qual eq tree.qual) && (mix == tree.mix) => tree
         case _ => finalize(tree, untpd.Super(qual, mix))
       }
-      def Apply(tree: Tree, fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = tree match {
+      def Apply(tree: Tree, fun: Tree, args: List[Tree]): Apply = tree match {
         case tree: Apply if (fun eq tree.fun) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.Apply(fun, args))
       }
-      def TypeApply(tree: Tree, fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = tree match {
+      def TypeApply(tree: Tree, fun: Tree, args: List[Tree]): TypeApply = tree match {
         case tree: TypeApply if (fun eq tree.fun) && (args eq tree.args) => tree
-        case _ => inst.TypeApply(fun, args).withPos(tree)
+        case _ => finalize(tree, untpd.TypeApply(fun, args))
       }
-      def Literal(tree: Tree, const: Constant)(implicit ctx: Context): Literal = tree match {
+      def Literal(tree: Tree, const: Constant): Literal = tree match {
         case tree: Literal if (const == tree.const) => tree
         case _ => finalize(tree, untpd.Literal(const))
       }
-      def New(tree: Tree, tpt: Tree)(implicit ctx: Context): New = tree match {
+      def New(tree: Tree, tpt: Tree): New = tree match {
         case tree: New if (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.New(tpt))
       }
-      def Pair(tree: Tree, left: Tree, right: Tree)(implicit ctx: Context): Pair = tree match {
+      def Pair(tree: Tree, left: Tree, right: Tree): Pair = tree match {
         case tree: Pair if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.Pair(left, right))
       }
-      def Typed(tree: Tree, expr: Tree, tpt: Tree)(implicit ctx: Context): Typed = tree match {
+      def Typed(tree: Tree, expr: Tree, tpt: Tree): Typed = tree match {
         case tree: Typed if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.Typed(expr, tpt))
       }
-      def NamedArg(tree: Tree, name: Name, arg: Tree)(implicit ctx: Context): NamedArg = tree match {
+      def NamedArg(tree: Tree, name: Name, arg: Tree): NamedArg = tree match {
         case tree: NamedArg if (name == tree.name) && (arg eq tree.arg) => tree
         case _ => finalize(tree, untpd.NamedArg(name, arg))
       }
-      def Assign(tree: Tree, lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign = tree match {
+      def Assign(tree: Tree, lhs: Tree, rhs: Tree): Assign = tree match {
         case tree: Assign if (lhs eq tree.lhs) && (rhs eq tree.rhs) => tree
         case _ => finalize(tree, untpd.Assign(lhs, rhs))
       }
-      def Block(tree: Tree, stats: List[Tree], expr: Tree)(implicit ctx: Context): Block = tree match {
+      def Block(tree: Tree, stats: List[Tree], expr: Tree): Block = tree match {
         case tree: Block if (stats eq tree.stats) && (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Block(stats, expr))
       }
-      def If(tree: Tree, cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = tree match {
+      def If(tree: Tree, cond: Tree, thenp: Tree, elsep: Tree): If = tree match {
         case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
         case _ => finalize(tree, untpd.If(cond, thenp, elsep))
       }
-      def Closure(tree: Tree, env: List[Tree], meth: RefTree)(implicit ctx: Context): Closure = tree match {
+      def Closure(tree: Tree, env: List[Tree], meth: RefTree): Closure = tree match {
         case tree: Closure if (env eq tree.env) && (meth eq tree.meth) => tree
         case _ => finalize(tree, untpd.Closure(env, meth))
       }
-      def Match(tree: Tree, selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = tree match {
+      def Match(tree: Tree, selector: Tree, cases: List[CaseDef]): Match = tree match {
         case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
         case _ => finalize(tree, untpd.Match(selector, cases))
       }
-      def CaseDef(tree: Tree, pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = tree match {
+      def CaseDef(tree: Tree, pat: Tree, guard: Tree, body: Tree): CaseDef = tree match {
         case tree: CaseDef if (pat eq tree.pat) && (guard eq tree.guard) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.CaseDef(pat, guard, body))
       }
-      def Return(tree: Tree, expr: Tree, from: Tree)(implicit ctx: Context): Return = tree match {
+      def Return(tree: Tree, expr: Tree, from: Tree): Return = tree match {
         case tree: Return if (expr eq tree.expr) && (from eq tree.from) => tree
         case _ => finalize(tree, untpd.Return(expr, from))
       }
-      def Try(tree: Tree, expr: Tree, handler: Tree, finalizer: Tree)(implicit ctx: Context): Try = tree match {
+      def Try(tree: Tree, expr: Tree, handler: Tree, finalizer: Tree): Try = tree match {
         case tree: Try if (expr eq tree.expr) && (handler eq tree.handler) && (finalizer eq tree.finalizer) => tree
         case _ => finalize(tree, untpd.Try(expr, handler, finalizer))
       }
-      def Throw(tree: Tree, expr: Tree)(implicit ctx: Context): Throw = tree match {
+      def Throw(tree: Tree, expr: Tree): Throw = tree match {
         case tree: Throw if (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Throw(expr))
       }
-      def SeqLiteral(tree: Tree, elems: List[Tree])(implicit ctx: Context): SeqLiteral = tree match {
+      def SeqLiteral(tree: Tree, elems: List[Tree]): SeqLiteral = tree match {
         case tree: SeqLiteral if (elems eq tree.elems) => tree
         case _ => finalize(tree, untpd.SeqLiteral(elems))
       }
-      def SingletonTypeTree(tree: Tree, ref: Tree)(implicit ctx: Context): SingletonTypeTree = tree match {
+      def SingletonTypeTree(tree: Tree, ref: Tree): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
         case _ => finalize(tree, untpd.SingletonTypeTree(ref))
       }
-      def SelectFromTypeTree(tree: Tree, qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree = tree match {
+      def SelectFromTypeTree(tree: Tree, qualifier: Tree, name: Name): SelectFromTypeTree = tree match {
         case tree: SelectFromTypeTree if (qualifier eq tree.qualifier) && (name == tree.name) => tree
         case _ => finalize(tree, untpd.SelectFromTypeTree(qualifier, name))
       }
-      def AndTypeTree(tree: Tree, left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree = tree match {
+      def AndTypeTree(tree: Tree, left: Tree, right: Tree): AndTypeTree = tree match {
         case tree: AndTypeTree if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.AndTypeTree(left, right))
       }
-      def OrTypeTree(tree: Tree, left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree = tree match {
+      def OrTypeTree(tree: Tree, left: Tree, right: Tree): OrTypeTree = tree match {
         case tree: OrTypeTree if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.OrTypeTree(left, right))
       }
-      def RefinedTypeTree(tree: Tree, tpt: Tree, refinements: List[Tree])(implicit ctx: Context): RefinedTypeTree = tree match {
+      def RefinedTypeTree(tree: Tree, tpt: Tree, refinements: List[Tree]): RefinedTypeTree = tree match {
         case tree: RefinedTypeTree if (tpt eq tree.tpt) && (refinements eq tree.refinements) => tree
         case _ => finalize(tree, untpd.RefinedTypeTree(tpt, refinements))
       }
-      def AppliedTypeTree(tree: Tree, tpt: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree = tree match {
+      def AppliedTypeTree(tree: Tree, tpt: Tree, args: List[Tree]): AppliedTypeTree = tree match {
         case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args))
       }
-      def TypeBoundsTree(tree: Tree, lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree = tree match {
+      def TypeBoundsTree(tree: Tree, lo: Tree, hi: Tree): TypeBoundsTree = tree match {
         case tree: TypeBoundsTree if (lo eq tree.lo) && (hi eq tree.hi) => tree
         case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi))
       }
-      def Bind(tree: Tree, name: Name, body: Tree)(implicit ctx: Context): Bind = tree match {
+      def Bind(tree: Tree, name: Name, body: Tree): Bind = tree match {
         case tree: Bind if (name eq tree.name) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.Bind(name, body))
       }
-      def Alternative(tree: Tree, trees: List[Tree])(implicit ctx: Context): Alternative = tree match {
+      def Alternative(tree: Tree, trees: List[Tree]): Alternative = tree match {
         case tree: Alternative if (trees eq tree.trees) => tree
         case _ => finalize(tree, untpd.Alternative(trees))
       }
-      def UnApply(tree: Tree, fun: Tree, args: List[Tree])(implicit ctx: Context): UnApply = tree match {
+      def UnApply(tree: Tree, fun: Tree, args: List[Tree]): UnApply = tree match {
         case tree: UnApply if (fun eq tree.fun) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.UnApply(fun, args))
       }
-      def ValDef(tree: Tree, mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree)(implicit ctx: Context): ValDef = tree match {
+      def ValDef(tree: Tree, mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef = tree match {
         case tree: ValDef if (mods == tree.mods) && (name == tree.name) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
         case _ => finalize(tree, untpd.ValDef(mods, name, tpt, rhs))
       }
-      def DefDef(tree: Tree, mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree)(implicit ctx: Context): DefDef = tree match {
+      def DefDef(tree: Tree, mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = tree match {
         case tree: DefDef if (mods == tree.mods) && (name == tree.name) && (tparams eq tree.tparams) && (vparamss eq tree.vparamss) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
         case _ => finalize(tree, untpd.DefDef(mods, name, tparams, vparamss, tpt, rhs))
       }
-      def TypeDef(tree: Tree, mods: Modifiers, name: TypeName, rhs: Tree, tparams: List[untpd.TypeDef] = Nil)(implicit ctx: Context): TypeDef = tree match {
+      def TypeDef(tree: Tree, mods: Modifiers, name: TypeName, rhs: Tree, tparams: List[untpd.TypeDef] = Nil): TypeDef = tree match {
         case tree: TypeDef if (mods == tree.mods) && (name == tree.name) && (rhs eq tree.rhs) && (tparams eq tree.tparams) => tree
         case _ => finalize(tree, untpd.TypeDef(mods, name, tparams, rhs))
       }
-      def Template(tree: Tree, constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree])(implicit ctx: Context): Template = tree match {
+      def Template(tree: Tree, constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree]): Template = tree match {
         case tree: Template if (constr eq tree.constr) && (parents eq tree.parents) && (self eq tree.self) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.Template(constr, parents, self, body))
       }
-      def Import(tree: Tree, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
+      def Import(tree: Tree, expr: Tree, selectors: List[untpd.Tree]): Import = tree match {
         case tree: Import if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
         case _ => finalize(tree, untpd.Import(expr, selectors))
       }
-      def PackageDef(tree: Tree, pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef = tree match {
+      def PackageDef(tree: Tree, pid: RefTree, stats: List[Tree]): PackageDef = tree match {
         case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
         case _ => finalize(tree, untpd.PackageDef(pid, stats))
       }
-      def Annotated(tree: Tree, annot: Tree, arg: Tree)(implicit ctx: Context): Annotated = tree match {
+      def Annotated(tree: Tree, annot: Tree, arg: Tree): Annotated = tree match {
         case tree: Annotated if (annot eq tree.annot) && (arg eq tree.arg) => tree
         case _ => finalize(tree, untpd.Annotated(annot, arg))
       }
-      def SharedTree(tree: Tree, shared: Tree)(implicit ctx: Context): SharedTree = tree match {
+      def SharedTree(tree: Tree, shared: Tree): SharedTree = tree match {
         case tree: SharedTree if (shared eq tree.shared) => tree
         case _ => finalize(tree, untpd.SharedTree(shared))
       }
-      def Thicket(tree: Tree, trees: List[Tree])(implicit ctx: Context): Thicket = tree match {
+      def Thicket(tree: Tree, trees: List[Tree]): Thicket = tree match {
         case tree: Thicket if (trees eq tree.trees) => tree
         case _ => finalize(tree, untpd.Thicket(trees))
       }
diff --git a/src/dotty/tools/dotc/ast/TypedTrees.scala b/src/dotty/tools/dotc/ast/TypedTrees.scala
index e4488ac79..cea799116 100644
--- a/src/dotty/tools/dotc/ast/TypedTrees.scala
+++ b/src/dotty/tools/dotc/ast/TypedTrees.scala
@@ -14,28 +14,23 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
     sym.annotations map (_.tree))
 
-  override def Ident(name: Name)(implicit ctx: Context): Ident = unsupported("Ident")
-  override def BackquotedIdent(name: Name)(implicit ctx: Context): BackquotedIdent = unsupported("BackquotedIdent")
-
   def Ident(tp: NamedType)(implicit ctx: Context): Ident =
-    super.Ident(tp.name).withType(tp.underlyingIfRepeated).checked
+    untpd.Ident(tp.name).withType(tp.underlyingIfRepeated).checked
 
-  override def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select =
+  def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select =
     Select(qualifier, NamedType(qualifier.tpe, name))
 
   def Select(pre: Tree, tp: NamedType)(implicit ctx: Context): Select =
-    super.Select(pre, tp.name).withType(tp).checked
+    untpd.Select(pre, tp.name).withType(tp).checked
 
-  override def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit ctx: Context) =
-    super.SelectWithSig(qualifier, name, sig)
+  def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit ctx: Context) =
+    untpd.SelectWithSig(qualifier, name, sig)
       .withType(TermRef.withSig(qualifier.tpe, name.asTermName, sig))
 
-  override def This(qual: TypeName)(implicit ctx: Context): This = unsupported("This")
-
   def This(cls: ClassSymbol)(implicit ctx: Context): This =
-    super.This(cls.name).withType(cls.thisType).checked
+    untpd.This(cls.name).withType(cls.thisType).checked
 
-  override def Super(qual: Tree, mix: TypeName)(implicit ctx: Context): Super = {
+  def Super(qual: Tree, mix: TypeName)(implicit ctx: Context): Super = {
     val owntype =
       if (mix.isEmpty) ctx.glb(qual.tpe.parents)
       else {
@@ -43,10 +38,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         check(mixParents.length == 1)
         mixParents.head
       }
-    super.Super(qual, mix).withType(SuperType(qual.tpe, owntype)).checked
+    untpd.Super(qual, mix).withType(SuperType(qual.tpe, owntype)).checked
   }
 
-  override def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
+  def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
     val owntype = fn.tpe.widen match {
       case fntpe @ MethodType(pnames, ptypes) =>
         check(sameLength(ptypes, args), s"${fn.show}: ${fntpe.show} to ${args.map(_.show).mkString(", ")}")
@@ -55,10 +50,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         check(false)
         ErrorType
     }
-    super.Apply(fn, args).withType(owntype).checked
+    untpd.Apply(fn, args).withType(owntype).checked
   }
 
-  override def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
+  def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
     val owntype = fn.tpe.widen match {
       case fntpe @ PolyType(pnames) =>
         check(sameLength(pnames, args))
@@ -67,32 +62,32 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         check(false)
         ErrorType
     }
-    super.TypeApply(fn, args).withType(owntype).checked
+    untpd.TypeApply(fn, args).withType(owntype).checked
   }
 
-  override def Literal(const: Constant)(implicit ctx: Context): Literal =
-    super.Literal(const).withType(const.tpe).checked
+  def Literal(const: Constant)(implicit ctx: Context): Literal =
+    untpd.Literal(const).withType(const.tpe).checked
 
-  override def New(tpt: Tree)(implicit ctx: Context): New =
-    super.New(tpt).withType(tpt.tpe).checked
+  def New(tpt: Tree)(implicit ctx: Context): New =
+    untpd.New(tpt).withType(tpt.tpe).checked
 
   def New(tp: Type)(implicit ctx: Context): New = New(TypeTree(tp))
 
-  override def Pair(left: Tree, right: Tree)(implicit ctx: Context): Pair =
-    super.Pair(left, right).withType(defn.PairType.appliedTo(left.tpe, right.tpe)).checked
+  def Pair(left: Tree, right: Tree)(implicit ctx: Context): Pair =
+    untpd.Pair(left, right).withType(defn.PairType.appliedTo(left.tpe, right.tpe)).checked
 
-  override def Typed(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed =
-    super.Typed(expr, tpt).withType(tpt.tpe).checked
+  def Typed(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed =
+    untpd.Typed(expr, tpt).withType(tpt.tpe).checked
 
-  override def NamedArg(name: Name, arg: Tree)(implicit ctx: Context) =
-    super.NamedArg(name, arg).withType(arg.tpe).checked
+  def NamedArg(name: Name, arg: Tree)(implicit ctx: Context) =
+    untpd.NamedArg(name, arg).withType(arg.tpe).checked
 
-  override def Assign(lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign =
-    super.Assign(lhs, rhs).withType(defn.UnitType).checked
+  def Assign(lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign =
+    untpd.Assign(lhs, rhs).withType(defn.UnitType).checked
 
-  override def Block(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block = {
+  def Block(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block = {
     lazy val locals = localSyms(stats).toSet
-    val blk = super.Block(stats, expr)
+    val blk = untpd.Block(stats, expr)
     def widen(tp: Type): Type = tp match {
       case tp: TermRef if locals contains tp.symbol =>
         widen(tp.info)
@@ -104,17 +99,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def maybeBlock(stats: List[Tree], expr: Tree)(implicit ctx: Context): Tree =
     if (stats.isEmpty) expr else Block(stats, expr)
 
-  override def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If =
-    super.If(cond, thenp, elsep).withType(thenp.tpe | elsep.tpe).checked
+  def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If =
+    untpd.If(cond, thenp, elsep).withType(thenp.tpe | elsep.tpe).checked
 
-  override def Closure(env: List[Tree], meth: RefTree)(implicit ctx: Context): Closure = {
+  def Closure(env: List[Tree], meth: RefTree)(implicit ctx: Context): Closure = {
     val ownType = meth.tpe.widen match {
       case mt @ MethodType(_, formals) =>
         assert(!mt.isDependent)
         val formals1 = formals mapConserve (_.underlyingIfRepeated)
         defn.FunctionType(formals1, mt.resultType)
     }
-    super.Closure(env, meth).withType(ownType).checked
+    untpd.Closure(env, meth).withType(ownType).checked
   }
 
   /** A function def
@@ -135,90 +130,82 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Closure(Nil, Ident(TermRef.withSym(NoPrefix, meth))))
   }
 
-  override def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match =
-    super.Match(selector, cases).withType(ctx.lub(cases map (_.body.tpe))).checked
+  def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match =
+    untpd.Match(selector, cases).withType(ctx.lub(cases map (_.body.tpe))).checked
 
-  override def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef =
-    super.CaseDef(pat, guard, body).withType(body.tpe).checked
+  def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef =
+    untpd.CaseDef(pat, guard, body).withType(body.tpe).checked
 
-  override def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return =
-    super.Return(expr, from).withType(defn.NothingType).checked
+  def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return =
+    untpd.Return(expr, from).withType(defn.NothingType).checked
 
-  override def Try(block: Tree, handler: Tree, finalizer: Tree)(implicit ctx: Context): Try =
-    super.Try(block, handler, finalizer).withType(block.tpe | handler.tpe).checked
+  def Try(block: Tree, handler: Tree, finalizer: Tree)(implicit ctx: Context): Try =
+    untpd.Try(block, handler, finalizer).withType(block.tpe | handler.tpe).checked
 
-  override def Throw(expr: Tree)(implicit ctx: Context): Throw =
-    super.Throw(expr).withType(defn.NothingType).checked
+  def Throw(expr: Tree)(implicit ctx: Context): Throw =
+    untpd.Throw(expr).withType(defn.NothingType).checked
 
-  override def SeqLiteral(elems: List[Tree])(implicit ctx: Context): SeqLiteral =
+  def SeqLiteral(elems: List[Tree])(implicit ctx: Context): SeqLiteral =
     SeqLiteral(defn.SeqClass.typeConstructor.appliedTo(
         ctx.lub(elems map (_.tpe)) :: Nil), elems)
 
   // TODO: Split into Java/Scala eq literals
   def SeqLiteral(tpe: Type, elems: List[Tree])(implicit ctx: Context): SeqLiteral =
-    super.SeqLiteral(elems).withType(tpe).checked
+    untpd.SeqLiteral(elems).withType(tpe).checked
 
-  override def TypeTree(): TypeTree = unsupported("TypeTree()")
-
-  override def TypeTree(original: Tree)(implicit ctx: Context): TypeTree =
+  def TypeTree(original: Tree)(implicit ctx: Context): TypeTree =
     TypeTree(original.tpe, original)
 
   def TypeTree(tp: Type, original: Tree = EmptyTree)(implicit ctx: Context): TypeTree =
-    super.TypeTree(original).withType(tp).checked
+    untpd.TypeTree(original).withType(tp).checked
 
-  override def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree =
-    super.SingletonTypeTree(ref).withType(ref.tpe).checked
+  def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree =
+    untpd.SingletonTypeTree(ref).withType(ref.tpe).checked
 
-  override def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree =
+  def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree =
     SelectFromTypeTree(qualifier, NamedType(qualifier.tpe, name))
 
   def SelectFromTypeTree(qualifier: Tree, tp: NamedType)(implicit ctx: Context): SelectFromTypeTree =
-    super.SelectFromTypeTree(qualifier, tp.name).withType(tp).checked
+    untpd.SelectFromTypeTree(qualifier, tp.name).withType(tp).checked
 
-  override def AndTypeTree(left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree =
-    super.AndTypeTree(left, right).withType(left.tpe & right.tpe).checked
+  def AndTypeTree(left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree =
+    untpd.AndTypeTree(left, right).withType(left.tpe & right.tpe).checked
 
-  override def OrTypeTree(left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree =
-    super.OrTypeTree(left, right).withType(left.tpe | right.tpe).checked
+  def OrTypeTree(left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree =
+    untpd.OrTypeTree(left, right).withType(left.tpe | right.tpe).checked
 
-  override def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit ctx: Context): RefinedTypeTree = {
+  def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit ctx: Context): RefinedTypeTree = {
     def refineType(tp: Type, refinement: Symbol): Type =
       RefinedType(tp, refinement.name, refinement.info)
-    super.RefinedTypeTree(tpt, refinements)
+    untpd.RefinedTypeTree(tpt, refinements)
       .withType((tpt.tpe /: (refinements map (_.symbol)))(refineType)).checked
   }
 
   def refineType(tp: Type, refinement: Symbol)(implicit ctx: Context): Type =
     RefinedType(tp, refinement.name, refinement.info)
 
-  override def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree =
-    super.AppliedTypeTree(tpt, args).withType(tpt.tpe.appliedTo(args map (_.tpe))).checked
-
-  override def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree =
-    super.TypeBoundsTree(lo, hi).withType(TypeBounds(lo.tpe, hi.tpe)).checked
+  def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree =
+    untpd.AppliedTypeTree(tpt, args).withType(tpt.tpe.appliedTo(args map (_.tpe))).checked
 
-  override def Bind(name: Name, body: Tree)(implicit ctx: Context): Bind = unsupported("Bind")
+  def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree =
+    untpd.TypeBoundsTree(lo, hi).withType(TypeBounds(lo.tpe, hi.tpe)).checked
 
   def Bind(sym: TermSymbol, body: Tree)(implicit ctx: Context): Bind =
-    super.Bind(sym.name, body).withType(refType(sym)).checked
+    untpd.Bind(sym.name, body).withType(refType(sym)).checked
 
-  override def Alternative(trees: List[Tree])(implicit ctx: Context): Alternative =
-    super.Alternative(trees).withType(ctx.lub(trees map (_.tpe))).checked
+  def Alternative(trees: List[Tree])(implicit ctx: Context): Alternative =
+    untpd.Alternative(trees).withType(ctx.lub(trees map (_.tpe))).checked
 
-  override def UnApply(fun: Tree, args: List[Tree])(implicit ctx: Context): UnApply = {
+  def UnApply(fun: Tree, args: List[Tree])(implicit ctx: Context): UnApply = {
     val owntype = fun.tpe.widen match {
       case MethodType(_, paramType :: Nil) => paramType
       case _ => check(false); ErrorType
     }
-    super.UnApply(fun, args).withType(owntype).checked
+    untpd.UnApply(fun, args).withType(owntype).checked
   }
 
-  override def ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree)(implicit ctx: Context): ValDef = unsupported("ValDef")
-
   def ValDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): ValDef =
-    super.ValDef(Modifiers(sym), sym.name, TypeTree(sym.info), rhs).withType(refType(sym)).checked
-
-  override def DefDef(mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree)(implicit ctx: Context): DefDef = unsupported("DefDef")
+    untpd.ValDef(Modifiers(sym), sym.name, TypeTree(sym.info), rhs).withType(refType(sym)).checked
 
   def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef =
     DefDef(sym, Function.const(rhs) _)
@@ -243,16 +230,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
     val (vparamss, rtp) = valueParamss(mtp)
     val argss = vparamss map (_ map (vparam => Ident(vparam.symRef)))
-    super.DefDef(
+    untpd.DefDef(
       Modifiers(sym), sym.name, tparams map TypeDef,
       vparamss map (_ map (ValDef(_))), TypeTree(rtp), rhsFn(argss))
       .withType(refType(sym)).checked
   }
 
-  override def TypeDef(mods: Modifiers, name: TypeName, rhs: Tree)(implicit ctx: Context): TypeDef = unsupported("TypeDef")
-
   def TypeDef(sym: TypeSymbol)(implicit ctx: Context): TypeDef =
-    super.TypeDef(Modifiers(sym), sym.name, TypeTree(sym.info))
+    untpd.TypeDef(Modifiers(sym), sym.name, TypeTree(sym.info))
       .withType(refType(sym)).checked
 
   def ClassDef(cls: ClassSymbol, typeParams: List[TypeSymbol], constr: DefDef, body: List[Tree])(implicit ctx: Context): TypeDef = {
@@ -271,22 +256,22 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val findLocalDummy = new FindLocalDummyAccumulator(cls)
     val localDummy = ((NoSymbol: Symbol) /: body)(findLocalDummy)
       .orElse(ctx.newLocalDummy(cls))
-    val impl = super.Template(constr, parents, selfType, rest)
+    val impl = untpd.Template(constr, parents, selfType, rest)
       .withType(refType(localDummy)).checked
-    super.TypeDef(Modifiers(cls), cls.name, impl) // !!! todo: revise
+    untpd.TypeDef(Modifiers(cls), cls.name, impl) // !!! todo: revise
       .withType(refType(cls)).checked
   }
 
-  override def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
-    super.Import(expr, selectors).withType(refType(ctx.newImportSymbol(SharedTree(expr)))).checked
+  def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
+    untpd.Import(expr, selectors).withType(refType(ctx.newImportSymbol(SharedTree(expr)))).checked
 
-  override def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef =
-    super.PackageDef(pid, stats).withType(refType(pid.symbol)).checked
+  def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef =
+    untpd.PackageDef(pid, stats).withType(refType(pid.symbol)).checked
 
-  override def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated =
-    super.Annotated(annot, arg).withType(AnnotatedType(Annotation(annot), arg.tpe)).checked
+  def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated =
+    untpd.Annotated(annot, arg).withType(AnnotatedType(Annotation(annot), arg.tpe)).checked
 
-  override def SharedTree(tree: Tree)(implicit ctx: Context): SharedTree =
+  def SharedTree(tree: Tree)(implicit ctx: Context): SharedTree =
     Trees.SharedTree(tree).withType(tree.tpe)
 
 
diff --git a/src/dotty/tools/dotc/ast/UntypedTrees.scala b/src/dotty/tools/dotc/ast/UntypedTrees.scala
index f8a03385e..22e8ab56e 100644
--- a/src/dotty/tools/dotc/ast/UntypedTrees.scala
+++ b/src/dotty/tools/dotc/ast/UntypedTrees.scala
@@ -4,7 +4,7 @@ package ast
 
 import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
-import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
+import Denotations._, SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
 import Decorators._
 import language.higherKinds
 import collection.mutable.ListBuffer
@@ -45,18 +45,76 @@ object untpd extends Trees.Instance[Untyped] with TreeInfo[Untyped] {
     override def withName(name: Name)(implicit ctx: Context) = cpy.PolyTypeDef(this, mods, name.toTypeName, tparams, rhs)
   }
 
-// ------ Additional creation methods for untyped only -----------------
+  // ------ Creation methods for untyped only -----------------
 
-  def Literal(const: Constant) = new Literal(const)
+  def Ident(name: Name): Ident = new Ident(name)
+  def BackquotedIdent(name: Name): BackquotedIdent = new BackquotedIdent(name)
+  def Select(qualifier: Tree, name: Name): Select = new Select(qualifier, name)
+  def SelectWithSig(qualifier: Tree, name: Name, sig: Signature): Select = new SelectWithSig(qualifier, name, sig)
+  def This(qual: TypeName): This = new This(qual)
+  def Super(qual: Tree, mix: TypeName): Super = new Super(qual, mix)
+  def Apply(fun: Tree, args: List[Tree]): Apply = new Apply(fun, args)
+  def TypeApply(fun: Tree, args: List[Tree]): TypeApply = new TypeApply(fun, args)
+  def Literal(const: Constant): Literal = new Literal(const)
+  def New(tpt: Tree): New = new New(tpt)
+  def Pair(left: Tree, right: Tree): Pair = new Pair(left, right)
+  def Typed(expr: Tree, tpt: Tree): Typed = new Typed(expr, tpt)
+  def NamedArg(name: Name, arg: Tree): NamedArg = new NamedArg(name, arg)
+  def Assign(lhs: Tree, rhs: Tree): Assign = new Assign(lhs, rhs)
+  def Block(stats: List[Tree], expr: Tree): Block = new Block(stats, expr)
+  def If(cond: Tree, thenp: Tree, elsep: Tree): If = new If(cond, thenp, elsep)
+  def Closure(env: List[Tree], meth: RefTree): Closure = new Closure(env, meth)
+  def Match(selector: Tree, cases: List[CaseDef]): Match = new Match(selector, cases)
+  def CaseDef(pat: Tree, guard: Tree, body: Tree): CaseDef = new CaseDef(pat, guard, body)
+  def Return(expr: Tree, from: Tree): Return = new Return(expr, from)
+  def Try(expr: Tree, handler: Tree, finalizer: Tree): Try = new Try(expr, handler, finalizer)
+  def Throw(expr: Tree): Throw = new Throw(expr)
+  def SeqLiteral(elems: List[Tree]): SeqLiteral = new SeqLiteral(elems)
+  def TypeTree(original: Tree): TypeTree = new TypeTree(original)
+  def TypeTree() = new TypeTree(EmptyTree)
+  def SingletonTypeTree(ref: Tree): SingletonTypeTree = new SingletonTypeTree(ref)
+  def SelectFromTypeTree(qualifier: Tree, name: Name): SelectFromTypeTree = new SelectFromTypeTree(qualifier, name)
+  def AndTypeTree(left: Tree, right: Tree): AndTypeTree = new AndTypeTree(left, right)
+  def OrTypeTree(left: Tree, right: Tree): OrTypeTree = new OrTypeTree(left, right)
+  def RefinedTypeTree(tpt: Tree, refinements: List[Tree]): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
+  def AppliedTypeTree(tpt: Tree, args: List[Tree]): AppliedTypeTree = new AppliedTypeTree(tpt, args)
+  def TypeBoundsTree(lo: Tree, hi: Tree): TypeBoundsTree = new TypeBoundsTree(lo, hi)
+  def Bind(name: Name, body: Tree): Bind = new Bind(name, body)
+  def Alternative(trees: List[Tree]): Alternative = new Alternative(trees)
+  def UnApply(fun: Tree, args: List[Tree]): UnApply = new UnApply(fun, args)
+  def ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree): ValDef = new ValDef(mods, name, tpt, rhs)
+  def DefDef(mods: Modifiers, name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef = new DefDef(mods, name, tparams, vparamss, tpt, rhs)
+  def TypeDef(mods: Modifiers, name: TypeName, rhs: Tree): TypeDef = new TypeDef(mods, name, rhs)
+  def Template(constr: DefDef, parents: List[Tree], self: ValDef, body: List[Tree]): Template = new Template(constr, parents, self, body)
+  def Import(expr: Tree, selectors: List[untpd.Tree]): Import = new Import(expr, selectors)
+  def PackageDef(pid: RefTree, stats: List[Tree]): PackageDef = new PackageDef(pid, stats)
+  def Annotated(annot: Tree, arg: Tree): Annotated = new Annotated(annot, arg)
+  def SharedTree(shared: Tree): SharedTree = new SharedTree(shared)
 
-  def TypeTree(tpe: Type)(implicit ctx: Context): TypedSplice = TypedSplice(TypeTree().withType(tpe))
+  // ------ Additional creation methods for untyped only -----------------
 
-  def TypeDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree)(implicit ctx: Context): TypeDef =
-    if (tparams.isEmpty) TypeDef(mods, name, rhs) else new PolyTypeDef(mods, name, tparams, rhs)
+  // def TypeTree(tpe: Type): TypeTree = TypeTree().withType(tpe) todo: move to untpd/tpd
+
+  /** new tpt(args1)...(args_n)
+   */
+  def New(tpt: Tree, argss: List[List[Tree]]): Tree =
+    ((Select(New(tpt), nme.CONSTRUCTOR): Tree) /: argss)(Apply(_, _))
+
+  def Block(stat: Tree, expr: Tree): Block =
+    Block(stat :: Nil, expr)
+
+  def Apply(fn: Tree, arg: Tree): Apply =
+    Apply(fn, arg :: Nil)
 
-// ------ Untyped tree values and creation methods ---------------------
+  def AppliedTypeTree(tpt: Tree, arg: Tree): AppliedTypeTree =
+    AppliedTypeTree(tpt, arg :: Nil)
+
+  def TypeTree(tpe: Type): TypedSplice = TypedSplice(TypeTree().withType(tpe))
+
+  def TypeDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree): TypeDef =
+    if (tparams.isEmpty) TypeDef(mods, name, rhs) else new PolyTypeDef(mods, name, tparams, rhs)
 
-  def unitLiteral(implicit ctx: Context) = Literal(Constant())
+  def unitLiteral = Literal(Constant())
 
   def ref(tp: NamedType)(implicit ctx: Context): Tree =
     TypedSplice(tpd.ref(tp))