diff --git a/docs/docs/reference/other-new-features/tasty-reflect.md b/docs/docs/reference/other-new-features/tasty-reflect.md
index a0f7603f224e..8f631b640f47 100644
--- a/docs/docs/reference/other-new-features/tasty-reflect.md
+++ b/docs/docs/reference/other-new-features/tasty-reflect.md
@@ -119,7 +119,7 @@ TASTy Reflect provides the following types:
          +- TypeTree ----+- Inferred
          |               +- TypeIdent
          |               +- TypeSelect
-         |               +- Project
+         |               +- Projection
          |               +- Singleton
          |               +- Refined
          |               +- Applied
diff --git a/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala b/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
index 3bc96e6e0e2f..fe298b49569a 100644
--- a/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
+++ b/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
@@ -9,14 +9,14 @@ trait TreeUtils {
   import reflect._
 
   /** Bind the `rhs` to a `val` and use it in `body` */
-  def let(rhs: Term)(body: Term.Ident => Term): Term = {
+  def let(rhs: Term)(body: Ident => Term): Term = {
     type T // TODO probably it is better to use the Sealed contruct rather than let the user create their own existential type
     implicit val rhsTpe: quoted.Type[T] = rhs.tpe.seal.asInstanceOf[quoted.Type[T]]
     val rhsExpr = rhs.seal[T]
     val expr = '{
       val x = $rhsExpr
       ${
-        val id = ('x).unseal.asInstanceOf[Term.Ident]
+        val id = ('x).unseal.asInstanceOf[Ident]
         body(id).seal[Any]
       }
     }
diff --git a/library/src-non-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala b/library/src-non-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
index 8fb39d2b2d02..b1843b7c77fe 100644
--- a/library/src-non-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
+++ b/library/src-non-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
@@ -7,7 +7,7 @@ trait TreeUtils {
   import reflect._
 
   /** Bind the `rhs` to a `val` and use it in `body` */
-  def let(rhs: Term)(bodyType: Type)(body: Term.Ident => Term): Term =
+  def let(rhs: Term)(bodyType: Type)(body: Ident => Term): Term =
     throw new Exception("non bootstrpped lib")
 
 }
diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala
index c852e8a22ac5..dcc3bde5b4fd 100644
--- a/library/src/scala/tasty/reflect/Core.scala
+++ b/library/src/scala/tasty/reflect/Core.scala
@@ -41,7 +41,7 @@ package scala.tasty.reflect
  *           +- TypeTree ----+- Inferred
  *           |               +- TypeIdent
  *           |               +- TypeSelect
- *           |               +- Project
+ *           |               +- Projection
  *           |               +- Singleton
  *           |               +- Refined
  *           |               +- Applied
@@ -160,12 +160,6 @@ trait Core {
       /** Tree representing an expression in the source code */
       type Term = kernel.Term
 
-      /** Trees representing an expression in the source code */
-      val Term: TermCoreModule
-
-      /** Trees representing an expression in the source code */
-      trait TermCoreModule {
-
         /** Tree representing a reference to definition */
         type Ref = kernel.Ref
 
@@ -235,17 +229,9 @@ trait Core {
         /** Tree representing a while loop */
         type While = kernel.While
 
-      }
-
       /** Type tree representing a type written in the source */
       type TypeTree = kernel.TypeTree
 
-      /** Type trees representing a type written in the source */
-      val TypeTree: TypeTreeCoreModule
-
-      /** Type trees representing a type written in the source */
-      trait TypeTreeCoreModule {
-
         /** Type tree representing an inferred type */
         type Inferred = kernel.Inferred
 
@@ -285,8 +271,6 @@ trait Core {
         /** Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }` */
         type TypeBlock = kernel.TypeBlock
 
-      }
-
       /** Type tree representing a type bound written in the source */
       type TypeBoundsTree = kernel.TypeBoundsTree
 
diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala
index 81a2a4bc7026..afcefca4db9a 100644
--- a/library/src/scala/tasty/reflect/Kernel.scala
+++ b/library/src/scala/tasty/reflect/Kernel.scala
@@ -40,7 +40,7 @@ package scala.tasty.reflect
  *           +- TypeTree ----+- Inferred
  *           |               +- TypeIdent
  *           |               +- TypeSelect
- *           |               +- Project
+ *           |               +- Projection
  *           |               +- Singleton
  *           |               +- Refined
  *           |               +- Applied
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
index 2f3ee70a5b00..b96d82f5d92c 100644
--- a/library/src/scala/tasty/reflect/Printers.scala
+++ b/library/src/scala/tasty/reflect/Printers.scala
@@ -147,48 +147,48 @@ trait Printers
       def result(): String = sb.result()
 
       def visitTree(x: Tree): Buffer = x match {
-        case Term.Ident(name) =>
-          this += "Term.Ident(\"" += name += "\")"
-        case Term.Select(qualifier, name) =>
-          this += "Term.Select(" += qualifier += ", \"" += name += "\")"
-        case Term.This(qual) =>
-          this += "Term.This(" += qual += ")"
-        case Term.Super(qual, mix) =>
-          this += "Term.Super(" += qual += ", " += mix += ")"
-        case Term.Apply(fun, args) =>
-          this += "Term.Apply(" += fun += ", " ++= args += ")"
-        case Term.TypeApply(fun, args) =>
-          this += "Term.TypeApply(" += fun += ", " ++= args += ")"
-        case Term.Literal(const) =>
-          this += "Term.Literal(" += const += ")"
-        case Term.New(tpt) =>
-          this += "Term.New(" += tpt += ")"
-        case Term.Typed(expr, tpt) =>
-          this += "Term.Typed(" += expr += ", "  += tpt += ")"
-        case Term.NamedArg(name, arg) =>
-          this += "Term.NamedArg(\"" += name += "\", " += arg += ")"
-        case Term.Assign(lhs, rhs) =>
-          this += "Term.Assign(" += lhs += ", " += rhs += ")"
-        case Term.Block(stats, expr) =>
-          this += "Term.Block(" ++= stats += ", " += expr += ")"
-        case Term.If(cond, thenp, elsep) =>
-          this += "Term.If(" += cond += ", " += thenp += ", " += elsep += ")"
-        case Term.Lambda(meth, tpt) =>
-          this += "Term.Lambda(" += meth += ", " += tpt += ")"
-        case Term.Match(selector, cases) =>
-          this += "Term.Match(" += selector += ", " ++= cases += ")"
-        case Term.ImplicitMatch(cases) =>
-          this += "Term.ImplicitMatch(" ++= cases += ")"
-        case Term.Return(expr) =>
-          this += "Term.Return(" += expr += ")"
-        case Term.While(cond, body) =>
-          this += "Term.While(" += cond += ", " += body += ")"
-        case Term.Try(block, handlers, finalizer) =>
-          this += "Term.Try(" += block += ", " ++= handlers += ", " += finalizer += ")"
-        case Term.Repeated(elems, elemtpt) =>
-          this += "Term.Repeated(" ++= elems += ", " += elemtpt += ")"
-        case Term.Inlined(call, bindings, expansion) =>
-          this += "Term.Inlined("
+        case Ident(name) =>
+          this += "Ident(\"" += name += "\")"
+        case Select(qualifier, name) =>
+          this += "Select(" += qualifier += ", \"" += name += "\")"
+        case This(qual) =>
+          this += "This(" += qual += ")"
+        case Super(qual, mix) =>
+          this += "Super(" += qual += ", " += mix += ")"
+        case Apply(fun, args) =>
+          this += "Apply(" += fun += ", " ++= args += ")"
+        case TypeApply(fun, args) =>
+          this += "TypeApply(" += fun += ", " ++= args += ")"
+        case Literal(const) =>
+          this += "Literal(" += const += ")"
+        case New(tpt) =>
+          this += "New(" += tpt += ")"
+        case Typed(expr, tpt) =>
+          this += "Typed(" += expr += ", "  += tpt += ")"
+        case NamedArg(name, arg) =>
+          this += "NamedArg(\"" += name += "\", " += arg += ")"
+        case Assign(lhs, rhs) =>
+          this += "Assign(" += lhs += ", " += rhs += ")"
+        case Block(stats, expr) =>
+          this += "Block(" ++= stats += ", " += expr += ")"
+        case If(cond, thenp, elsep) =>
+          this += "If(" += cond += ", " += thenp += ", " += elsep += ")"
+        case Lambda(meth, tpt) =>
+          this += "Lambda(" += meth += ", " += tpt += ")"
+        case Match(selector, cases) =>
+          this += "Match(" += selector += ", " ++= cases += ")"
+        case ImplicitMatch(cases) =>
+          this += "ImplicitMatch(" ++= cases += ")"
+        case Return(expr) =>
+          this += "Return(" += expr += ")"
+        case While(cond, body) =>
+          this += "While(" += cond += ", " += body += ")"
+        case Try(block, handlers, finalizer) =>
+          this += "Try(" += block += ", " ++= handlers += ", " += finalizer += ")"
+        case Repeated(elems, elemtpt) =>
+          this += "Repeated(" ++= elems += ", " += elemtpt += ")"
+        case Inlined(call, bindings, expansion) =>
+          this += "Inlined("
           visitOption(call, visitTree)
           this += ", " ++= bindings += ", " += expansion += ")"
         case ValDef(name, tpt, rhs) =>
@@ -209,36 +209,36 @@ trait Printers
           this += "Import(" += importImplied += ", " += expr += ", " ++= selectors += ")"
         case PackageClause(pid, stats) =>
           this += "PackageClause(" += pid += ", " ++= stats += ")"
-        case TypeTree.Inferred() =>
-          this += "TypeTree.Inferred()"
-        case TypeTree.TypeIdent(name) =>
-          this += "TypeTree.TypeIdent(\"" += name += "\")"
-        case TypeTree.TypeSelect(qualifier, name) =>
-          this += "TypeTree.TypeSelect(" += qualifier += ", \"" += name += "\")"
-        case TypeTree.Projection(qualifier, name) =>
-          this += "TypeTree.Projection(" += qualifier += ", \"" += name += "\")"
-        case TypeTree.Singleton(ref) =>
-          this += "TypeTree.Singleton(" += ref += ")"
-        case TypeTree.Refined(tpt, refinements) =>
-          this += "TypeTree.Refined(" += tpt += ", " ++= refinements += ")"
-        case TypeTree.Applied(tpt, args) =>
-          this += "TypeTree.Applied(" += tpt += ", " ++= args += ")"
-        case TypeTree.ByName(result) =>
-          this += "TypeTree.ByName(" += result += ")"
-        case TypeTree.Annotated(arg, annot) =>
-          this += "TypeTree.Annotated(" += arg += ", " += annot += ")"
-        case TypeTree.LambdaTypeTree(tparams, body) =>
-          this += "TypeTree.LambdaTypeTree(" ++= tparams += ", " += body += ")"
-        case TypeTree.TypeBind(name, bounds) =>
-          this += "TypeTree.TypeBind(" += name += ", " += bounds += ")"
-        case TypeTree.TypeBlock(aliases, tpt) =>
-          this += "TypeTree.TypeBlock(" ++= aliases += ", " += tpt += ")"
+        case Inferred() =>
+          this += "Inferred()"
+        case TypeIdent(name) =>
+          this += "TypeIdent(\"" += name += "\")"
+        case TypeSelect(qualifier, name) =>
+          this += "TypeSelect(" += qualifier += ", \"" += name += "\")"
+        case Projection(qualifier, name) =>
+          this += "Projection(" += qualifier += ", \"" += name += "\")"
+        case Singleton(ref) =>
+          this += "Singleton(" += ref += ")"
+        case Refined(tpt, refinements) =>
+          this += "Refined(" += tpt += ", " ++= refinements += ")"
+        case Applied(tpt, args) =>
+          this += "Applied(" += tpt += ", " ++= args += ")"
+        case ByName(result) =>
+          this += "ByName(" += result += ")"
+        case Annotated(arg, annot) =>
+          this += "Annotated(" += arg += ", " += annot += ")"
+        case LambdaTypeTree(tparams, body) =>
+          this += "LambdaTypeTree(" ++= tparams += ", " += body += ")"
+        case TypeBind(name, bounds) =>
+          this += "TypeBind(" += name += ", " += bounds += ")"
+        case TypeBlock(aliases, tpt) =>
+          this += "TypeBlock(" ++= aliases += ", " += tpt += ")"
         case TypeBoundsTree(lo, hi) =>
           this += "TypeBoundsTree(" += lo += ", " += hi += ")"
         case WildcardTypeTree() =>
           this += s"WildcardTypeTree()"
-        case TypeTree.MatchTypeTree(bound, selector, cases) =>
-          this += "TypeTree.MatchTypeTree(" += bound += ", " += selector += ", " ++= cases += ")"
+        case MatchTypeTree(bound, selector, cases) =>
+          this += "MatchTypeTree(" += bound += ", " += selector += ", " ++= cases += ")"
         case CaseDef(pat, guard, body) =>
           this += "CaseDef(" += pat += ", " += guard += ", " += body += ")"
         case TypeCaseDef(pat, body) =>
@@ -522,7 +522,7 @@ trait Printers
         case PackageObject(body)=>
           printTree(body) // Print package object
 
-        case PackageClause(Term.Ident(name), (inner @ PackageClause(_, _)) :: Nil) if name != "<empty>" && PackageObject.unapply(inner).isEmpty =>
+        case PackageClause(Ident(name), (inner @ PackageClause(_, _)) :: Nil) if name != "<empty>" && PackageObject.unapply(inner).isEmpty =>
           // print inner package as `package outer.inner { ... }`
           printTree(inner)
 
@@ -533,7 +533,7 @@ trait Printers
             case stat @ Import(_, _, _) => stat
           }
           name match {
-            case Term.Ident("<empty>") =>
+            case Ident("<empty>") =>
               printTrees(stats1, lineBreak())
             case _ =>
               this += "package "
@@ -574,9 +574,9 @@ trait Printers
           }
 
           val parents1 = parents.filter {
-            case IsTerm(Term.Apply(Term.Select(Term.New(tpt), _), _)) => !Types.JavaLangObject.unapply(tpt.tpe)
-            case IsTypeTree(TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Product")) => false
-            case IsTypeTree(TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Serializable")) => false
+            case IsTerm(Apply(Select(New(tpt), _), _)) => !Types.JavaLangObject.unapply(tpt.tpe)
+            case IsTypeTree(TypeSelect(Select(Ident("_root_"), "scala"), "Product")) => false
+            case IsTypeTree(TypeSelect(Select(Ident("_root_"), "scala"), "Serializable")) => false
             case _ => true
           }
           if (parents1.nonEmpty)
@@ -585,17 +585,17 @@ trait Printers
           def printParent(parent: Tree /* Term | TypeTree */, needEmptyParens: Boolean = false): Unit = parent match {
             case IsTypeTree(parent) =>
               printTypeTree(parent)(Some(cdef.symbol))
-            case IsTerm(Term.TypeApply(fun, targs)) =>
+            case IsTerm(TypeApply(fun, targs)) =>
               printParent(fun)
-            case IsTerm(Term.Apply(fun@Term.Apply(_,_), args)) =>
+            case IsTerm(Apply(fun@Apply(_,_), args)) =>
               printParent(fun, true)
               if (!args.isEmpty || needEmptyParens)
                 inParens(printTrees(args, ", ")(Some(cdef.symbol)))
-            case IsTerm(Term.Apply(fun, args)) =>
+            case IsTerm(Apply(fun, args)) =>
               printParent(fun)
               if (!args.isEmpty || needEmptyParens)
                 inParens(printTrees(args, ", ")(Some(cdef.symbol)))
-            case IsTerm(Term.Select(Term.IsNew(newTree), _)) =>
+            case IsTerm(Select(IsNew(newTree), _)) =>
               printType(newTree.tpe)(Some(cdef.symbol))
             case IsTerm(parent) =>
               throw new MatchError(parent.show)
@@ -658,7 +658,7 @@ trait Printers
             this += lineBreak() += "}"
           }
           self match {
-            case Some(ValDef(_, TypeTree.Singleton(_), _)) =>
+            case Some(ValDef(_, Singleton(_), _)) =>
               if (stats1.nonEmpty)
                 printBody(printSelf = false)
             case Some(ValDef(_, _, _)) =>
@@ -698,9 +698,9 @@ trait Printers
               this
           }
 
-        case Term.While(cond, body) =>
+        case While(cond, body) =>
           (cond, body) match {
-            case (Term.Block(Term.Block(Nil, body1) :: Nil, Term.Block(Nil, cond1)), Term.Literal(Constant.Unit())) =>
+            case (Block(Block(Nil, body1) :: Nil, Block(Nil, cond1)), Literal(Constant.Unit())) =>
               this += highlightKeyword("do ", color)
               printTree(body1) += highlightKeyword(" while ", color)
               inParens(printTree(cond1))
@@ -751,22 +751,22 @@ trait Printers
           }
           this
 
-        case Term.Ident("_") =>
+        case Ident("_") =>
           this += "_"
 
-        case IsTerm(tree @ Term.Ident(_)) =>
+        case IsTerm(tree @ Ident(_)) =>
           printType(tree.tpe)
 
-        case Term.Select(qual, name) =>
+        case Select(qual, name) =>
           printQualTree(qual)
           if (name != "<init>" && name != "package")
             this += "." += name
           this
 
-        case Term.Literal(const) =>
+        case Literal(const) =>
           printConstant(const)
 
-        case Term.This(id) =>
+        case This(id) =>
           id match {
             case Some(x) =>
               this += x.name.stripSuffix("$") += "."
@@ -774,11 +774,11 @@ trait Printers
           }
           this += "this"
 
-        case Term.IsNew(tree) =>
+        case IsNew(tree) =>
           this += "new "
           printType(tree.tpe)
 
-        case Term.NamedArg(name, arg) =>
+        case NamedArg(name, arg) =>
           this += name += " = "
           printTree(arg)
 
@@ -786,9 +786,9 @@ trait Printers
           this += "throw "
           printTree(expr)
 
-        case Term.Apply(fn, args) if fn.symbol.fullName == "scala.internal.Quoted$.exprQuote" =>
+        case Apply(fn, args) if fn.symbol.fullName == "scala.internal.Quoted$.exprQuote" =>
           args.head match {
-            case Term.Block(stats, expr) =>
+            case Block(stats, expr) =>
               this += "'{"
               indented {
                 this += lineBreak()
@@ -801,48 +801,48 @@ trait Printers
               this += "}"
           }
 
-        case Term.TypeApply(fn, args) if fn.symbol.fullName == "scala.internal.Quoted$.typeQuote" =>
+        case TypeApply(fn, args) if fn.symbol.fullName == "scala.internal.Quoted$.typeQuote" =>
           this += "'["
           printTypeTree(args.head)
           this += "]"
 
-        case Term.Apply(fn, args) =>
+        case Apply(fn, args) =>
           fn match {
-            case Term.Select(Term.This(_), "<init>") => this += "this" // call to constructor inside a constructor
+            case Select(This(_), "<init>") => this += "this" // call to constructor inside a constructor
             case _ => printQualTree(fn)
           }
           val args1 = args match {
-            case init :+ Term.Typed(Term.Repeated(Nil, _), _) => init // drop empty var args at the end
+            case init :+ Typed(Repeated(Nil, _), _) => init // drop empty var args at the end
             case _ => args
           }
 
           inParens(printTrees(args1, ", "))
 
-        case Term.TypeApply(fn, args) =>
+        case TypeApply(fn, args) =>
           printQualTree(fn)
           fn match {
-            case Term.Select(Term.New(TypeTree.Applied(_, _)), "<init>") =>
+            case Select(New(Applied(_, _)), "<init>") =>
               // type bounds already printed in `fn`
               this
             case _ =>
               inSquare(printTrees(args, ", "))
           }
 
-        case Term.Super(qual, idOpt) =>
+        case Super(qual, idOpt) =>
           qual match {
-            case Term.This(Some(Id(name))) => this += name += "."
-            case Term.This(None) =>
+            case This(Some(Id(name))) => this += name += "."
+            case This(None) =>
           }
           this += "super"
           for (id <- idOpt)
             inSquare(this += id.name)
           this
 
-        case Term.Typed(term, tpt) =>
+        case Typed(term, tpt) =>
           tpt.tpe match {
             case Types.Repeated(_) =>
               term match {
-                case Term.Repeated(_, _) =>
+                case Repeated(_, _) =>
                   printTree(term)
                 case _ =>
                   printTree(term)
@@ -866,26 +866,26 @@ trait Printers
               }
           }
 
-        case Term.Assign(lhs, rhs) =>
+        case Assign(lhs, rhs) =>
           printTree(lhs)
           this += " = "
           printTree(rhs)
 
-        case Term.Block(stats0, expr) =>
+        case Block(stats0, expr) =>
           val stats = stats0.filter {
             case IsValDef(tree) => !tree.symbol.flags.is(Flags.Object)
             case _ => true
           }
           printFlatBlock(stats, expr)
 
-        case Term.Inlined(_, bindings, expansion) =>
+        case Inlined(_, bindings, expansion) =>
           printFlatBlock(bindings, expansion)
 
-        case Term.Lambda(meth, tpt) =>
+        case Lambda(meth, tpt) =>
           // Printed in by it's DefDef
           this
 
-        case Term.If(cond, thenp, elsep) =>
+        case If(cond, thenp, elsep) =>
           this += highlightKeyword("if ", color)
           inParens(printTree(cond))
           this += " "
@@ -893,16 +893,16 @@ trait Printers
           this+= highlightKeyword(" else ", color)
           printTree(elsep)
 
-        case Term.Match(selector, cases) =>
+        case Match(selector, cases) =>
           printQualTree(selector)
           this += highlightKeyword(" match", color)
           inBlock(printCases(cases, lineBreak()))
 
-        case Term.ImplicitMatch(cases) =>
+        case ImplicitMatch(cases) =>
           this += highlightKeyword("implicit match", color)
           inBlock(printCases(cases, lineBreak()))
 
-        case Term.Try(body, cases, finallyOpt) =>
+        case Try(body, cases, finallyOpt) =>
           this += highlightKeyword("try ", color)
           printTree(body)
           if (cases.nonEmpty) {
@@ -917,11 +917,11 @@ trait Printers
               this
           }
 
-        case Term.Return(expr) =>
+        case Return(expr) =>
           this += "return "
           printTree(expr)
 
-        case Term.Repeated(elems, _) =>
+        case Repeated(elems, _) =>
           printTrees(elems, ", ")
 
         case TypeBoundsTree(lo, hi) =>
@@ -942,7 +942,7 @@ trait Printers
       }
 
       def printQualTree(tree: Tree): Buffer = tree match {
-        case Term.IsIf(_) | Term.IsMatch(_) | Term.IsWhile(_) | Term.IsTry(_) | Term.IsReturn(_) =>
+        case IsIf(_) | IsMatch(_) | IsWhile(_) | IsTry(_) | IsReturn(_) =>
           this += "("
           printTree(tree)
           this += ")"
@@ -952,26 +952,26 @@ trait Printers
       def flatBlock(stats: List[Statement], expr: Term): (List[Statement], Term) = {
         val flatStats = List.newBuilder[Statement]
         def extractFlatStats(stat: Statement): Unit = stat match {
-          case Term.Block(stats1, expr1) =>
+          case Block(stats1, expr1) =>
             val it = stats1.iterator
             while (it.hasNext)
               extractFlatStats(it.next())
             extractFlatStats(expr1)
-          case Term.Inlined(_, bindings, expansion) =>
+          case Inlined(_, bindings, expansion) =>
             val it = bindings.iterator
             while (it.hasNext)
               extractFlatStats(it.next())
             extractFlatStats(expansion)
-          case Term.Literal(Constant.Unit()) => // ignore
+          case Literal(Constant.Unit()) => // ignore
           case stat => flatStats += stat
         }
         def extractFlatExpr(term: Term): Term = term match {
-          case Term.Block(stats1, expr1) =>
+          case Block(stats1, expr1) =>
             val it = stats1.iterator
             while (it.hasNext)
               extractFlatStats(it.next())
             extractFlatExpr(expr1)
-          case Term.Inlined(_, bindings, expansion) =>
+          case Inlined(_, bindings, expansion) =>
             val it = bindings.iterator
             while (it.hasNext)
               extractFlatStats(it.next())
@@ -987,10 +987,10 @@ trait Printers
 
       def printFlatBlock(stats: List[Statement], expr: Term)(implicit elideThis: Option[Symbol]): Buffer = {
         val (stats1, expr1) = flatBlock(stats, expr)
-        // Remove Term.Lambda nodes, lambdas are printed by their definition
-        val stats2 = stats1.filter { case Term.Lambda(_, _) => false; case _ => true }
+        // Remove Lambda nodes, lambdas are printed by their definition
+        val stats2 = stats1.filter { case Lambda(_, _) => false; case _ => true }
         val (stats3, expr3) = expr1 match {
-          case Term.Lambda(_, _) =>
+          case Lambda(_, _) =>
             val init :+ last  = stats2
             (init, last)
           case _ => (stats2, expr1)
@@ -1010,12 +1010,12 @@ trait Printers
         def printSeparator(next: Tree): Unit = {
           // Avoid accidental application of opening `{` on next line with a double break
           def rec(next: Tree): Unit = next match {
-            case Term.Block(stats, _) if stats.nonEmpty => this += doubleLineBreak()
-            case Term.Inlined(_, bindings, _) if bindings.nonEmpty => this += doubleLineBreak()
-            case Term.Select(qual, _) => rec(qual)
-            case Term.Apply(fn, _) => rec(fn)
-            case Term.TypeApply(fn, _) => rec(fn)
-            case Term.Typed(_, _) => this += doubleLineBreak()
+            case Block(stats, _) if stats.nonEmpty => this += doubleLineBreak()
+            case Inlined(_, bindings, _) if bindings.nonEmpty => this += doubleLineBreak()
+            case Select(qual, _) => rec(qual)
+            case Apply(fn, _) => rec(fn)
+            case TypeApply(fn, _) => rec(fn)
+            case Typed(_, _) => this += doubleLineBreak()
             case _ => this += lineBreak()
           }
           next match {
@@ -1169,7 +1169,7 @@ trait Printers
           case IsTypeBoundsTree(rhs) => printBoundsTree(rhs)
           case IsWildcardTypeTree(rhs) =>
             printTypeOrBound(rhs.tpe)
-          case rhs @ TypeTree.LambdaTypeTree(tparams, body) =>
+          case rhs @ LambdaTypeTree(tparams, body) =>
             def printParam(t: Tree /*TypeTree | TypeBoundsTree*/): Unit = t match {
               case IsTypeBoundsTree(t) => printBoundsTree(t)
               case IsTypeTree(t) => printTypeTree(t)
@@ -1188,7 +1188,7 @@ trait Printers
             inSquare(printSeparated(tparams))
             if (isMember) {
               body match {
-                case TypeTree.MatchTypeTree(Some(bound), _, _) =>
+                case MatchTypeTree(Some(bound), _, _) =>
                   this +=  " <: "
                   printTypeTree(bound)
                 case _ =>
@@ -1273,7 +1273,7 @@ trait Printers
         this += highlightValDef(" =>", color)
         indented {
           caseDef.rhs match {
-            case Term.Block(stats, expr) =>
+            case Block(stats, expr) =>
               printStats(stats, expr)(None)
             case body =>
               this += lineBreak()
@@ -1294,11 +1294,11 @@ trait Printers
       def printPattern(pattern: Pattern): Buffer = pattern match {
         case Pattern.Value(v) =>
           v match {
-            case Term.Ident("_") => this += "_"
+            case Ident("_") => this += "_"
             case _ => printTree(v)
           }
 
-        case Pattern.Bind(name, Pattern.Value(Term.Ident("_"))) =>
+        case Pattern.Bind(name, Pattern.Value(Ident("_"))) =>
           this += name
 
         case Pattern.Bind(name, Pattern.TypeTest(tpt)) =>
@@ -1311,8 +1311,8 @@ trait Printers
 
         case Pattern.Unapply(fun, implicits, patterns) =>
           fun match {
-            case Term.Select(extractor, "unapply" | "unapplySeq") => printTree(extractor)
-            case Term.TypeApply(Term.Select(extractor, "unapply" | "unapplySeq"), _) => printTree(extractor)
+            case Select(extractor, "unapply" | "unapplySeq") => printTree(extractor)
+            case TypeApply(Select(extractor, "unapply" | "unapplySeq"), _) => printTree(extractor)
             case _ => throw new MatchError(fun.show)
           }
           inParens(printPatterns(patterns, ", "))
@@ -1369,7 +1369,7 @@ trait Printers
        *   prefix `C.this` to avoid type checking errors.
        */
       def printTypeTree(tree: TypeTree)(implicit elideThis: Option[Symbol] = None): Buffer = tree match {
-        case TypeTree.Inferred() =>
+        case Inferred() =>
           // TODO try to move this logic into `printType`
           def printTypeAndAnnots(tpe: Type): Buffer = tpe match {
             case Type.AnnotatedType(tp, annot) =>
@@ -1389,31 +1389,31 @@ trait Printers
           }
           printTypeAndAnnots(tree.tpe)
 
-        case TypeTree.TypeIdent(name) =>
+        case TypeIdent(name) =>
           printType(tree.tpe)
 
-        case TypeTree.TypeSelect(qual, name) =>
+        case TypeSelect(qual, name) =>
           printTree(qual) += "." += highlightTypeDef(name, color)
 
-        case TypeTree.Projection(qual, name) =>
+        case Projection(qual, name) =>
           printTypeTree(qual) += "#" += highlightTypeDef(name, color)
 
-        case TypeTree.Singleton(ref) =>
+        case Singleton(ref) =>
           printTree(ref)
           ref match {
-            case Term.Literal(_) => this
+            case Literal(_) => this
             case _ => this += ".type"
           }
 
-        case TypeTree.Refined(tpt, refinements) =>
+        case Refined(tpt, refinements) =>
           printTypeTree(tpt)
           inBlock(printTrees(refinements, "; "))
 
-        case TypeTree.Applied(tpt, args) =>
+        case Applied(tpt, args) =>
           printTypeTree(tpt)
           inSquare(printTrees(args, ", "))
 
-        case TypeTree.Annotated(tpt, annot) =>
+        case Annotated(tpt, annot) =>
           val Annotation(ref, args) = annot
           ref.tpe match {
             case Types.RepeatedAnnotation() =>
@@ -1426,24 +1426,24 @@ trait Printers
               printAnnotation(annot)
           }
 
-        case TypeTree.MatchTypeTree(bound, selector, cases) =>
+        case MatchTypeTree(bound, selector, cases) =>
           printTypeTree(selector)
           this += highlightKeyword(" match ", color)
           inBlock(printTypeCases(cases, lineBreak()))
 
-        case TypeTree.ByName(result) =>
+        case ByName(result) =>
           this += highlightTypeDef("=> ", color)
           printTypeTree(result)
 
-        case TypeTree.LambdaTypeTree(tparams, body) =>
+        case LambdaTypeTree(tparams, body) =>
           printTargsDefs(tparams.zip(tparams), isDef = false)
           this += highlightTypeDef(" => ", color)
           printTypeOrBoundsTree(body)
 
-        case TypeTree.TypeBind(name, _) =>
+        case TypeBind(name, _) =>
           this += highlightTypeDef(name, color)
 
-        case TypeTree.TypeBlock(aliases, tpt) =>
+        case TypeBlock(aliases, tpt) =>
           inBlock {
             printTrees(aliases, lineBreak())
             printTypeTree(tpt)
@@ -1710,13 +1710,13 @@ trait Printers
 
       def printBoundsTree(bounds: TypeBoundsTree)(implicit elideThis: Option[Symbol]): Buffer = {
         bounds.low match {
-          case TypeTree.Inferred() =>
+          case Inferred() =>
           case low =>
             this += " >: "
             printTypeTree(low)
         }
         bounds.hi match {
-          case TypeTree.Inferred() => this
+          case Inferred() => this
           case hi =>
             this += " <: "
             printTypeTree(hi)
@@ -1798,7 +1798,7 @@ trait Printers
 
     private object SpecialOp {
       def unapply(arg: Tree)(implicit ctx: Context): Option[(String, List[Term])] = arg match {
-        case IsTerm(arg @ Term.Apply(fn, args)) =>
+        case IsTerm(arg @ Apply(fn, args)) =>
           fn.tpe match {
             case Type.SymRef(IsDefDefSymbol(sym), Type.ThisType(Type.SymRef(sym2, _))) if sym2.name == "<special-ops>" =>
               Some((sym.tree.name, args))
@@ -1810,9 +1810,9 @@ trait Printers
 
     private object Annotation {
       def unapply(arg: Tree)(implicit ctx: Context): Option[(TypeTree, List[Term])] = arg match {
-        case Term.New(annot) => Some((annot, Nil))
-        case Term.Apply(Term.Select(Term.New(annot), "<init>"), args) => Some((annot, args))
-        case Term.Apply(Term.TypeApply(Term.Select(Term.New(annot), "<init>"), targs), args) => Some((annot, args))
+        case New(annot) => Some((annot, Nil))
+        case Apply(Select(New(annot), "<init>"), args) => Some((annot, args))
+        case Apply(TypeApply(Select(New(annot), "<init>"), targs), args) => Some((annot, args))
         case _ => None
       }
     }
diff --git a/library/src/scala/tasty/reflect/SymbolOps.scala b/library/src/scala/tasty/reflect/SymbolOps.scala
index 49de26d96bc3..902104640c3b 100644
--- a/library/src/scala/tasty/reflect/SymbolOps.scala
+++ b/library/src/scala/tasty/reflect/SymbolOps.scala
@@ -190,7 +190,7 @@ trait SymbolOps extends Core {
 
   implicit class TypeBindSymbolAPI(self: TypeBindSymbol) {
     /** TypeBind pattern of this definition */
-    def tree(implicit ctx: Context): TypeTree.TypeBind =
+    def tree(implicit ctx: Context): TypeBind =
       kernel.TypeBindSymbol_tree(self)
   }
 
diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala
index f6d80f0d4327..e89b39c4b95b 100644
--- a/library/src/scala/tasty/reflect/TreeOps.scala
+++ b/library/src/scala/tasty/reflect/TreeOps.scala
@@ -18,16 +18,16 @@ trait TreeOps extends Core {
   }
 
   object PackageClause {
-    def apply(pid: Term.Ref, stats: List[Tree])(implicit ctx: Context): PackageClause =
+    def apply(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause =
       kernel.PackageClause_apply(pid, stats)
-    def copy(original: PackageClause)(pid: Term.Ref, stats: List[Tree])(implicit ctx: Context): PackageClause =
+    def copy(original: PackageClause)(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause =
       kernel.PackageClause_copy(original)(pid, stats)
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term.Ref, List[Tree])] =
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Ref, List[Tree])] =
       kernel.matchPackageClause(tree).map(x => (x.pid, x.stats))
   }
 
   implicit class PackageClauseAPI(self: PackageClause) {
-    def pid(implicit ctx: Context): Term.Ref = kernel.PackageClause_pid(self)
+    def pid(implicit ctx: Context): Ref = kernel.PackageClause_pid(self)
     def stats(implicit ctx: Context): List[Tree] = kernel.PackageClause_stats(self)
   }
 
@@ -187,573 +187,569 @@ trait TreeOps extends Core {
       kernel.matchTerm(tree)
   }
 
-  /** Scala term. Any tree that can go in expression position. */
-  object Term extends TermCoreModule {
+  object Ref {
 
-    object IsIdent {
-      /** Matches any Ident and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Ident] = kernel.matchIdent(tree)
-    }
+    /** Create a reference tree */
+    def apply(sym: Symbol)(implicit ctx: Context): Ref =
+      kernel.Ref_apply(sym)
 
-    object Ref {
+    // TODO def copy(original: Tree)(name: String)(implicit ctx: Context): Ref
 
-      /** Create a reference tree */
-      def apply(sym: Symbol)(implicit ctx: Context): Ref =
-        kernel.Ref_apply(sym)
-
-      // TODO def copy(original: Tree)(name: String)(implicit ctx: Context): Ref
+  }
 
-    }
+  object IsIdent {
+    /** Matches any Ident and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Ident] = kernel.matchIdent(tree)
+  }
 
-    /** Scala term identifier */
-    object Ident {
-      def apply(tmref: TermRef)(implicit ctx: Context): Term =
-        kernel.Ident_apply(tmref)
+  implicit class IdentAPI(self: Ident) {
+    def name(implicit ctx: Context): String = kernel.Ident_name(self)
+  }
 
-      def copy(original: Tree)(name: String)(implicit ctx: Context): Ident =
-        kernel.Ident_copy(original)(name)
+  /** Scala term identifier */
+  object Ident {
+    def apply(tmref: TermRef)(implicit ctx: Context): Term =
+      kernel.Ident_apply(tmref)
 
-      /** Matches a term identifier and returns its name */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[String] =
-        kernel.matchIdent(tree).map(_.name)
-    }
+    def copy(original: Tree)(name: String)(implicit ctx: Context): Ident =
+      kernel.Ident_copy(original)(name)
 
-    object IsSelect {
-      /** Matches any Select and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = kernel.matchSelect(tree)
-    }
+    /** Matches a term identifier and returns its name */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[String] =
+      kernel.matchIdent(tree).map(_.name)
+  }
 
-    /** Scala term selection */
-    object Select {
-      /** Select a field or a non-overloaded method by name
-       *
-       *  @note The method will produce an assertion error if the selected
-       *        method is overloaded. The method `overloaded` should be used
-       *        in that case.
-       */
-      def unique(qualifier: Term, name: String)(implicit ctx: Context): Select =
-        kernel.Select_unique(qualifier, name)
+  object IsSelect {
+    /** Matches any Select and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = kernel.matchSelect(tree)
+  }
 
-      // TODO rename, this returns an Apply and not a Select
-      /** Call an overloaded method with the given type and term parameters */
-      def overloaded(qualifier: Term, name: String, targs: List[Type], args: List[Term])(implicit ctx: Context): Apply =
-        kernel.Select_overloaded(qualifier, name, targs, args)
+  /** Scala term selection */
+  object Select {
+    /** Select a field or a non-overloaded method by name
+     *
+     *  @note The method will produce an assertion error if the selected
+     *        method is overloaded. The method `overloaded` should be used
+     *        in that case.
+     */
+    def unique(qualifier: Term, name: String)(implicit ctx: Context): Select =
+      kernel.Select_unique(qualifier, name)
 
-      def copy(original: Tree)(qualifier: Term, name: String)(implicit ctx: Context): Select =
-        kernel.Select_copy(original)(qualifier, name)
+    // TODO rename, this returns an Apply and not a Select
+    /** Call an overloaded method with the given type and term parameters */
+    def overloaded(qualifier: Term, name: String, targs: List[Type], args: List[Term])(implicit ctx: Context): Apply =
+      kernel.Select_overloaded(qualifier, name, targs, args)
 
-      /** Matches `<qualifier: Term>.<name: String>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] =
-        kernel.matchSelect(tree).map(x => (x.qualifier, x.name))
-    }
+    def copy(original: Tree)(qualifier: Term, name: String)(implicit ctx: Context): Select =
+      kernel.Select_copy(original)(qualifier, name)
 
-    object IsLiteral {
-      /** Matches any Literal and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Literal] = kernel.matchLiteral(tree)
-    }
+    /** Matches `<qualifier: Term>.<name: String>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] =
+      kernel.matchSelect(tree).map(x => (x.qualifier, x.name))
+  }
 
-    /** Scala literal constant */
-    object Literal {
+  implicit class SelectAPI(self: Select) {
+    def qualifier(implicit ctx: Context): Term = kernel.Select_qualifier(self)
+    def name(implicit ctx: Context): String = kernel.Select_name(self)
+    def signature(implicit ctx: Context): Option[Signature] = kernel.Select_signature(self)
+  }
 
-      /** Create a literal constant */
-      def apply(constant: Constant)(implicit ctx: Context): Literal =
-        kernel.Literal_apply(constant)
+  object IsLiteral {
+    /** Matches any Literal and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Literal] = kernel.matchLiteral(tree)
+  }
 
-      def copy(original: Tree)(constant: Constant)(implicit ctx: Context): Literal =
-        kernel.Literal_copy(original)(constant)
+  /** Scala literal constant */
+  object Literal {
 
-      /** Matches a literal constant */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Constant] =
-        kernel.matchLiteral(tree).map(_.constant)
-    }
+    /** Create a literal constant */
+    def apply(constant: Constant)(implicit ctx: Context): Literal =
+      kernel.Literal_apply(constant)
 
-    object IsThis {
-      /** Matches any This and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[This] = kernel.matchThis(tree)
-    }
+    def copy(original: Tree)(constant: Constant)(implicit ctx: Context): Literal =
+      kernel.Literal_copy(original)(constant)
 
-    /** Scala `this` or `this[id]` */
-    object This {
+    /** Matches a literal constant */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Constant] =
+      kernel.matchLiteral(tree).map(_.constant)
+  }
 
-      /** Create a `this[<id: Id]>` */
-      def apply(cls: ClassDefSymbol)(implicit ctx: Context): This =
-        kernel.This_apply(cls)
+  implicit class LiteralAPI(self:  Literal) {
+    def constant(implicit ctx: Context): Constant = kernel.Literal_constant(self)
+  }
 
-      def copy(original: Tree)(qual: Option[Id])(implicit ctx: Context): This =
-        kernel.This_copy(original)(qual)
+  object IsThis {
+    /** Matches any This and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[This] = kernel.matchThis(tree)
+  }
 
-      /** Matches `this[<id: Option[Id]>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Option[Id]] =
-        kernel.matchThis(tree).map(_.id)
+  /** Scala `this` or `this[id]` */
+  object This {
 
-    }
+    /** Create a `this[<id: Id]>` */
+    def apply(cls: ClassDefSymbol)(implicit ctx: Context): This =
+      kernel.This_apply(cls)
 
-    object IsNew {
-      /** Matches any New and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[New] = kernel.matchNew(tree)
-    }
+    def copy(original: Tree)(qual: Option[Id])(implicit ctx: Context): This =
+      kernel.This_copy(original)(qual)
 
-    /** Scala `new` */
-    object New {
+    /** Matches `this[<id: Option[Id]>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Option[Id]] =
+      kernel.matchThis(tree).map(_.id)
 
-      /** Create a `new <tpt: TypeTree>` */
-      def apply(tpt: TypeTree)(implicit ctx: Context): New =
-        kernel.New_apply(tpt)
+  }
 
-      def copy(original: Tree)(tpt: TypeTree)(implicit ctx: Context): New =
-        kernel.New_copy(original)(tpt)
+  implicit class ThisAPI(self:  This) {
+    def id(implicit ctx: Context): Option[Id] = kernel.This_id(self)
+  }
 
-      /** Matches a `new <tpt: TypeTree>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] =
-        kernel.matchNew(tree).map(_.tpt)
-    }
+  object IsNew {
+    /** Matches any New and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[New] = kernel.matchNew(tree)
+  }
 
-    object IsNamedArg {
-      /** Matches any NamedArg and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[NamedArg] = kernel.matchNamedArg(tree)
-    }
+  /** Scala `new` */
+  object New {
 
-    /** Scala named argument `x = y` in argument position */
-    object NamedArg {
+    /** Create a `new <tpt: TypeTree>` */
+    def apply(tpt: TypeTree)(implicit ctx: Context): New =
+      kernel.New_apply(tpt)
 
-      /** Create a named argument `<name: String> = <value: Term>` */
-      def apply(name: String, arg: Term)(implicit ctx: Context): NamedArg =
-        kernel.NamedArg_apply(name, arg)
+    def copy(original: Tree)(tpt: TypeTree)(implicit ctx: Context): New =
+      kernel.New_copy(original)(tpt)
 
-      def copy(original: NamedArg)(name: String, arg: Term)(implicit ctx: Context): NamedArg =
-        kernel.NamedArg_copy(original)(name, arg)
+    /** Matches a `new <tpt: TypeTree>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] =
+      kernel.matchNew(tree).map(_.tpt)
+  }
 
-      /** Matches a named argument `<name: String> = <value: Term>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Term)] =
-        kernel.matchNamedArg(tree).map(x => (x.name, x.value))
+  implicit class NewAPI(self: New) {
+    def tpt(implicit ctx: Context): TypeTree = kernel.New_tpt(self)
+  }
 
-    }
+  object IsNamedArg {
+    /** Matches any NamedArg and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[NamedArg] = kernel.matchNamedArg(tree)
+  }
 
-    object IsApply {
-      /** Matches any Apply and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Apply] = kernel.matchApply(tree)
-    }
+  /** Scala named argument `x = y` in argument position */
+  object NamedArg {
 
-    /** Scala parameter application */
-    object Apply {
+    /** Create a named argument `<name: String> = <value: Term>` */
+    def apply(name: String, arg: Term)(implicit ctx: Context): NamedArg =
+      kernel.NamedArg_apply(name, arg)
 
-      /** Create a function application `<fun: Term>(<args: List[Term]>)` */
-      def apply(fun: Term, args: List[Term])(implicit ctx: Context): Apply =
-        kernel.Apply_apply(fun, args)
+    def copy(original: NamedArg)(name: String, arg: Term)(implicit ctx: Context): NamedArg =
+      kernel.NamedArg_copy(original)(name, arg)
 
-      def copy(original: Tree)(fun: Term, args: List[Term])(implicit ctx: Context): Apply =
-        kernel.Apply_copy(original)(fun, args)
+    /** Matches a named argument `<name: String> = <value: Term>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Term)] =
+      kernel.matchNamedArg(tree).map(x => (x.name, x.value))
 
-      /** Matches a function application `<fun: Term>(<args: List[Term]>)` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[Term])] =
-        kernel.matchApply(tree).map(x => (x.fun, x.args))
-    }
+  }
 
-    object IsTypeApply {
-      /** Matches any TypeApply and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeApply] =
-        kernel.matchTypeApply(tree)
-    }
+  implicit class NamedArgAPI(self: NamedArg) {
+    def name(implicit ctx: Context): String = kernel.NamedArg_name(self)
+    def value(implicit ctx: Context): Term = kernel.NamedArg_value(self)
+  }
 
-    /** Scala type parameter application */
-    object TypeApply {
+  object IsApply {
+    /** Matches any Apply and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Apply] = kernel.matchApply(tree)
+  }
 
-      /** Create a function type application `<fun: Term>[<args: List[TypeTree]>]` */
-      def apply(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply =
-        kernel.TypeApply_apply(fun, args)
+  /** Scala parameter application */
+  object Apply {
 
-      def copy(original: Tree)(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply =
-        kernel.TypeApply_copy(original)(fun, args)
+    /** Create a function application `<fun: Term>(<args: List[Term]>)` */
+    def apply(fun: Term, args: List[Term])(implicit ctx: Context): Apply =
+      kernel.Apply_apply(fun, args)
 
-      /** Matches a function type application `<fun: Term>[<args: List[TypeTree]>]` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[TypeTree])] =
-        kernel.matchTypeApply(tree).map(x => (x.fun, x.args))
+    def copy(original: Tree)(fun: Term, args: List[Term])(implicit ctx: Context): Apply =
+      kernel.Apply_copy(original)(fun, args)
 
-    }
+    /** Matches a function application `<fun: Term>(<args: List[Term]>)` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[Term])] =
+      kernel.matchApply(tree).map(x => (x.fun, x.args))
+  }
 
-    object IsSuper {
-      /** Matches any Super and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Super] = kernel.matchSuper(tree)
-    }
+  implicit class ApplyAPI(self: Apply) {
+    def fun(implicit ctx: Context): Term = kernel.Apply_fun(self)
+    def args(implicit ctx: Context): List[Term] = kernel.Apply_args(self)
+  }
 
-    /** Scala `x.super` or `x.super[id]` */
-    object Super {
+  object IsTypeApply {
+    /** Matches any TypeApply and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeApply] =
+      kernel.matchTypeApply(tree)
+  }
 
-      /** Creates a `<qualifier: Term>.super[<id: Option[Id]>` */
-      def apply(qual: Term, mix: Option[Id])(implicit ctx: Context): Super =
-        kernel.Super_apply(qual, mix)
+  /** Scala type parameter application */
+  object TypeApply {
 
-      def copy(original: Tree)(qual: Term, mix: Option[Id])(implicit ctx: Context): Super =
-        kernel.Super_copy(original)(qual, mix)
+    /** Create a function type application `<fun: Term>[<args: List[TypeTree]>]` */
+    def apply(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply =
+      kernel.TypeApply_apply(fun, args)
 
-      /** Matches a `<qualifier: Term>.super[<id: Option[Id]>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[Id])] =
-        kernel.matchSuper(tree).map(x => (x.qualifier, x.id))
-    }
+    def copy(original: Tree)(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply =
+      kernel.TypeApply_copy(original)(fun, args)
 
-    object IsTyped {
-      /** Matches any Typed and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Typed] = kernel.matchTyped(tree)
-    }
+    /** Matches a function type application `<fun: Term>[<args: List[TypeTree]>]` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[TypeTree])] =
+      kernel.matchTypeApply(tree).map(x => (x.fun, x.args))
 
-    /** Scala ascription `x: T` */
-    object Typed {
+  }
 
-      /** Create a type ascription `<x: Term>: <tpt: TypeTree>` */
-      def apply(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed =
-        kernel.Typed_apply(expr, tpt)
+  implicit class TypeApplyAPI(self: TypeApply) {
+    def fun(implicit ctx: Context): Term = kernel.TypeApply_fun(self)
+    def args(implicit ctx: Context): List[TypeTree] = kernel.TypeApply_args(self)
+  }
 
-      def copy(original: Tree)(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed =
-        kernel.Typed_copy(original)(expr, tpt)
+  object IsSuper {
+    /** Matches any Super and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Super] = kernel.matchSuper(tree)
+  }
 
-      /** Matches `<expr: Term>: <tpt: TypeTree>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, TypeTree)] =
-        kernel.matchTyped(tree).map(x => (x.expr, x.tpt))
+  /** Scala `x.super` or `x.super[id]` */
+  object Super {
 
-    }
+    /** Creates a `<qualifier: Term>.super[<id: Option[Id]>` */
+    def apply(qual: Term, mix: Option[Id])(implicit ctx: Context): Super =
+      kernel.Super_apply(qual, mix)
 
-    object IsAssign {
-      /** Matches any Assign and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Assign] = kernel.matchAssign(tree)
-    }
+    def copy(original: Tree)(qual: Term, mix: Option[Id])(implicit ctx: Context): Super =
+      kernel.Super_copy(original)(qual, mix)
 
-    /** Scala assign `x = y` */
-    object Assign {
+    /** Matches a `<qualifier: Term>.super[<id: Option[Id]>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[Id])] =
+      kernel.matchSuper(tree).map(x => (x.qualifier, x.id))
+  }
 
-      /** Create an assignment `<lhs: Term> = <rhs: Term>` */
-      def apply(lhs: Term, rhs: Term)(implicit ctx: Context): Assign =
-        kernel.Assign_apply(lhs, rhs)
+  implicit class SuperAPI(self: Super) {
+    def qualifier(implicit ctx: Context): Term = kernel.Super_qualifier(self)
+    def id(implicit ctx: Context): Option[Id] = kernel.Super_id(self)
+  }
 
-      def copy(original: Tree)(lhs: Term, rhs: Term)(implicit ctx: Context): Assign =
-        kernel.Assign_copy(original)(lhs, rhs)
+  object IsTyped {
+    /** Matches any Typed and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Typed] = kernel.matchTyped(tree)
+  }
 
-      /** Matches an assignment `<lhs: Term> = <rhs: Term>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)] =
-        kernel.matchAssign(tree).map(x => (x.lhs, x.rhs))
-    }
+  /** Scala ascription `x: T` */
+  object Typed {
 
-    object IsBlock {
-      /** Matches any Block and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Block] = kernel.matchBlock(tree)
-    }
+    /** Create a type ascription `<x: Term>: <tpt: TypeTree>` */
+    def apply(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed =
+      kernel.Typed_apply(expr, tpt)
 
-    /** Scala code block `{ stat0; ...; statN; expr }` term */
-    object Block {
+    def copy(original: Tree)(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed =
+      kernel.Typed_copy(original)(expr, tpt)
 
-      /** Creates a block `{ <statements: List[Statement]>; <expr: Term> }` */
-      def apply(stats: List[Statement], expr: Term)(implicit ctx: Context): Block =
-        kernel.Block_apply(stats, expr)
+    /** Matches `<expr: Term>: <tpt: TypeTree>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, TypeTree)] =
+      kernel.matchTyped(tree).map(x => (x.expr, x.tpt))
 
-      def copy(original: Tree)(stats: List[Statement], expr: Term)(implicit ctx: Context): Block =
-        kernel.Block_copy(original)(stats, expr)
+  }
 
-      /** Matches a block `{ <statements: List[Statement]>; <expr: Term> }` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Statement], Term)] =
-        kernel.matchBlock(tree).map(x => (x.statements, x.expr))
-    }
+  implicit class TypedAPI(self: Typed) {
+    def expr(implicit ctx: Context): Term = kernel.Typed_expr(self)
+    def tpt(implicit ctx: Context): TypeTree = kernel.Typed_tpt(self)
+  }
 
-    object IsLambda {
-      /** Matches any Lambda and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Lambda] = kernel.matchLambda(tree)
-    }
+  object IsAssign {
+    /** Matches any Assign and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Assign] = kernel.matchAssign(tree)
+  }
 
-    object Lambda {
+  /** Scala assign `x = y` */
+  object Assign {
 
-      def apply(meth: Term, tpt: Option[TypeTree])(implicit ctx: Context): Lambda =
-        kernel.Lambda_apply(meth, tpt)
+    /** Create an assignment `<lhs: Term> = <rhs: Term>` */
+    def apply(lhs: Term, rhs: Term)(implicit ctx: Context): Assign =
+      kernel.Assign_apply(lhs, rhs)
 
-      def copy(original: Tree)(meth: Tree, tpt: Option[TypeTree])(implicit ctx: Context): Lambda =
-        kernel.Lambda_copy(original)(meth, tpt)
+    def copy(original: Tree)(lhs: Term, rhs: Term)(implicit ctx: Context): Assign =
+      kernel.Assign_copy(original)(lhs, rhs)
 
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[TypeTree])] =
-        kernel.matchLambda(tree).map(x => (x.meth, x.tptOpt))
-    }
+    /** Matches an assignment `<lhs: Term> = <rhs: Term>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)] =
+      kernel.matchAssign(tree).map(x => (x.lhs, x.rhs))
+  }
 
-    object IsIf {
-      /** Matches any If and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[If] = kernel.matchIf(tree)
-    }
+  implicit class AssignAPI(self: Assign) {
+    def lhs(implicit ctx: Context): Term = kernel.Assign_lhs(self)
+    def rhs(implicit ctx: Context): Term = kernel.Assign_rhs(self)
+  }
 
-    /** Scala `if`/`else` term */
-    object If {
+  object IsBlock {
+    /** Matches any Block and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Block] = kernel.matchBlock(tree)
+  }
 
-      /** Create an if/then/else `if (<cond: Term>) <thenp: Term> else <elsep: Term>` */
-      def apply(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If =
-        kernel.If_apply(cond, thenp, elsep)
+  /** Scala code block `{ stat0; ...; statN; expr }` term */
+  object Block {
 
-      def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If =
-        kernel.If_copy(original)(cond, thenp, elsep)
+    /** Creates a block `{ <statements: List[Statement]>; <expr: Term> }` */
+    def apply(stats: List[Statement], expr: Term)(implicit ctx: Context): Block =
+      kernel.Block_apply(stats, expr)
 
-      /** Matches an if/then/else `if (<cond: Term>) <thenp: Term> else <elsep: Term>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term, Term)] =
-        kernel.matchIf(tree).map(x => (x.cond, x.thenp, x.elsep))
+    def copy(original: Tree)(stats: List[Statement], expr: Term)(implicit ctx: Context): Block =
+      kernel.Block_copy(original)(stats, expr)
 
-    }
+    /** Matches a block `{ <statements: List[Statement]>; <expr: Term> }` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Statement], Term)] =
+      kernel.matchBlock(tree).map(x => (x.statements, x.expr))
+  }
 
-    object IsMatch {
-      /** Matches any Match and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Match] = kernel.matchMatch(tree)
-    }
+  implicit class BlockAPI(self: Block) {
+    def statements(implicit ctx: Context): List[Statement] = kernel.Block_statements(self)
+    def expr(implicit ctx: Context): Term = kernel.Block_expr(self)
+  }
 
-    /** Scala `match` term */
-    object Match {
+  object IsLambda {
+    /** Matches any Lambda and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Lambda] = kernel.matchLambda(tree)
+  }
 
-      /** Creates a pattern match `<scrutinee: Term> match { <cases: List[CaseDef]> }` */
-      def apply(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match =
-        kernel.Match_apply(selector, cases)
+  object Lambda {
 
-      def copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match =
-        kernel.Match_copy(original)(selector, cases)
+    def apply(meth: Term, tpt: Option[TypeTree])(implicit ctx: Context): Lambda =
+      kernel.Lambda_apply(meth, tpt)
 
-      /** Matches a pattern match `<scrutinee: Term> match { <cases: List[CaseDef]> }` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef])] =
-        kernel.matchMatch(tree).map(x => (x.scrutinee, x.cases))
+    def copy(original: Tree)(meth: Tree, tpt: Option[TypeTree])(implicit ctx: Context): Lambda =
+      kernel.Lambda_copy(original)(meth, tpt)
 
-    }
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[TypeTree])] =
+      kernel.matchLambda(tree).map(x => (x.meth, x.tptOpt))
+  }
 
-    object IsImplicitMatch {
-      /** Matches any ImplicitMatch and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[ImplicitMatch] = kernel.matchImplicitMatch(tree)
-    }
+  implicit class LambdaAPI(self: Lambda) {
+    def meth(implicit ctx: Context): Term = kernel.Lambda_meth(self)
+    def tptOpt(implicit ctx: Context): Option[TypeTree] = kernel.Lambda_tptOpt(self)
+  }
 
-    /** Scala implicit `match` term */
-    object ImplicitMatch {
+  object IsIf {
+    /** Matches any If and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[If] = kernel.matchIf(tree)
+  }
 
-      /** Creates a pattern match `implicit match { <cases: List[CaseDef]> }` */
-      def apply(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
-        kernel.ImplicitMatch_apply(cases)
+  /** Scala `if`/`else` term */
+  object If {
 
-      def copy(original: Tree)(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
-        kernel.ImplicitMatch_copy(original)(cases)
+    /** Create an if/then/else `if (<cond: Term>) <thenp: Term> else <elsep: Term>` */
+    def apply(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If =
+      kernel.If_apply(cond, thenp, elsep)
 
-      /** Matches a pattern match `implicit match { <cases: List[CaseDef]> }` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[List[CaseDef]] =
-        kernel.matchImplicitMatch(tree).map(_.cases)
+    def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If =
+      kernel.If_copy(original)(cond, thenp, elsep)
 
-    }
+    /** Matches an if/then/else `if (<cond: Term>) <thenp: Term> else <elsep: Term>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term, Term)] =
+      kernel.matchIf(tree).map(x => (x.cond, x.thenp, x.elsep))
 
-    object IsTry {
-      /** Matches any Try and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Try] = kernel.matchTry(tree)
-    }
+  }
 
-    /** Scala `try`/`catch`/`finally` term */
-    object Try {
+  implicit class IfAPI(self: If) {
+    def cond(implicit ctx: Context): Term = kernel.If_cond(self)
+    def thenp(implicit ctx: Context): Term = kernel.If_thenp(self)
+    def elsep(implicit ctx: Context): Term = kernel.If_elsep(self)
+  }
 
-      /** Create a try/catch `try <body: Term> catch { <cases: List[CaseDef]> } finally <finalizer: Option[Term]>` */
-      def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try =
-        kernel.Try_apply(expr, cases, finalizer)
+  object IsMatch {
+    /** Matches any Match and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Match] = kernel.matchMatch(tree)
+  }
 
-      def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try =
-        kernel.Try_copy(original)(expr, cases, finalizer)
+  /** Scala `match` term */
+  object Match {
 
-      /** Matches a try/catch `try <body: Term> catch { <cases: List[CaseDef]> } finally <finalizer: Option[Term]>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])] =
-        kernel.matchTry(tree).map(x => (x.body, x.cases, x.finalizer))
+    /** Creates a pattern match `<scrutinee: Term> match { <cases: List[CaseDef]> }` */
+    def apply(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match =
+      kernel.Match_apply(selector, cases)
 
-    }
+    def copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match =
+      kernel.Match_copy(original)(selector, cases)
 
-    object IsReturn {
-      /** Matches any Return and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Return] = kernel.matchReturn(tree)
-    }
+    /** Matches a pattern match `<scrutinee: Term> match { <cases: List[CaseDef]> }` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef])] =
+      kernel.matchMatch(tree).map(x => (x.scrutinee, x.cases))
 
-    /** Scala local `return` */
-    object Return {
+  }
 
-      /** Creates `return <expr: Term>` */
-      def apply(expr: Term)(implicit ctx: Context): Return =
-        kernel.Return_apply(expr)
+  implicit class MatchAPI(self: Match) {
+    def scrutinee(implicit ctx: Context): Term = kernel.Match_scrutinee(self)
+    def cases(implicit ctx: Context): List[CaseDef] = kernel.Match_cases(self)
+  }
 
-      def copy(original: Tree)(expr: Term)(implicit ctx: Context): Return =
-        kernel.Return_copy(original)(expr)
+  object IsImplicitMatch {
+    /** Matches any ImplicitMatch and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[ImplicitMatch] = kernel.matchImplicitMatch(tree)
+  }
 
-      /** Matches `return <expr: Term>` */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
-        kernel.matchReturn(tree).map(_.expr)
+  /** Scala implicit `match` term */
+  object ImplicitMatch {
 
-    }
+    /** Creates a pattern match `implicit match { <cases: List[CaseDef]> }` */
+    def apply(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
+      kernel.ImplicitMatch_apply(cases)
 
-    object IsRepeated {
-      /** Matches any Repeated and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Repeated] = kernel.matchRepeated(tree)
-    }
+    def copy(original: Tree)(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
+      kernel.ImplicitMatch_copy(original)(cases)
 
-    object Repeated {
+    /** Matches a pattern match `implicit match { <cases: List[CaseDef]> }` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[List[CaseDef]] =
+      kernel.matchImplicitMatch(tree).map(_.cases)
 
-      def apply(elems: List[Term], tpt: TypeTree)(implicit ctx: Context): Repeated =
-        kernel.Repeated_apply(elems, tpt)
+  }
 
-      def copy(original: Tree)(elems: List[Term], tpt: TypeTree)(implicit ctx: Context): Repeated =
-        kernel.Repeated_copy(original)(elems, tpt)
+  implicit class ImplicitMatchAPI(self: ImplicitMatch) {
+    def cases(implicit ctx: Context): List[CaseDef] = kernel.ImplicitMatch_cases(self)
+  }
 
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Term], TypeTree)] =
-        kernel.matchRepeated(tree).map(x => (x.elems, x.elemtpt))
+  object IsTry {
+    /** Matches any Try and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Try] = kernel.matchTry(tree)
+  }
 
-    }
+  /** Scala `try`/`catch`/`finally` term */
+  object Try {
 
-    object IsInlined {
-      /** Matches any Inlined and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Inlined] = kernel.matchInlined(tree)
-    }
+    /** Create a try/catch `try <body: Term> catch { <cases: List[CaseDef]> } finally <finalizer: Option[Term]>` */
+    def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try =
+      kernel.Try_apply(expr, cases, finalizer)
 
-    object Inlined {
+    def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try =
+      kernel.Try_copy(original)(expr, cases, finalizer)
 
-      def apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
-        kernel.Inlined_apply(call, bindings, expansion)
+    /** Matches a try/catch `try <body: Term> catch { <cases: List[CaseDef]> } finally <finalizer: Option[Term]>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])] =
+      kernel.matchTry(tree).map(x => (x.body, x.cases, x.finalizer))
 
-      def copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
-        kernel.Inlined_copy(original)(call, bindings, expansion)
+  }
 
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[Tree /* Term | TypeTree */], List[Definition], Term)] =
-        kernel.matchInlined(tree).map(x => (x.call, x.bindings, x.body))
+  implicit class TryAPI(self: Try) {
+    def body(implicit ctx: Context): Term = kernel.Try_body(self)
+    def cases(implicit ctx: Context): List[CaseDef] = kernel.Try_cases(self)
+    def finalizer(implicit ctx: Context): Option[Term] = kernel.Try_finalizer(self)
+  }
 
-    }
+  object IsReturn {
+    /** Matches any Return and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Return] = kernel.matchReturn(tree)
+  }
 
-    object IsSelectOuter {
-      /** Matches any SelectOuter and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[SelectOuter] = kernel.matchSelectOuter(tree)
-    }
+  /** Scala local `return` */
+  object Return {
 
-    object SelectOuter {
+    /** Creates `return <expr: Term>` */
+    def apply(expr: Term)(implicit ctx: Context): Return =
+      kernel.Return_apply(expr)
 
-      def apply(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter =
-        kernel.SelectOuter_apply(qualifier, name, levels)
+    def copy(original: Tree)(expr: Term)(implicit ctx: Context): Return =
+      kernel.Return_copy(original)(expr)
 
-      def copy(original: Tree)(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter =
-        kernel.SelectOuter_copy(original)(qualifier, name, levels)
+    /** Matches `return <expr: Term>` */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
+      kernel.matchReturn(tree).map(_.expr)
 
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Int, Type)] = // TODO homogenize order of parameters
-        kernel.matchSelectOuter(tree).map(x => (x.qualifier, x.level, x.tpe))
+  }
 
-    }
+  implicit class ReturnAPI(self: Return) {
+    def expr(implicit ctx: Context): Term = kernel.Return_expr(self)
+  }
 
-    object IsWhile {
-      /** Matches any While and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[While] = kernel.matchWhile(tree)
-    }
+  object IsRepeated {
+    /** Matches any Repeated and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Repeated] = kernel.matchRepeated(tree)
+  }
 
-    object While {
+  object Repeated {
 
-      /** Creates a while loop `while (<cond>) <body>` and returns (<cond>, <body>) */
-      def apply(cond: Term, body: Term)(implicit ctx: Context): While =
-        kernel.While_apply(cond, body)
+    def apply(elems: List[Term], tpt: TypeTree)(implicit ctx: Context): Repeated =
+      kernel.Repeated_apply(elems, tpt)
 
-      def copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While =
-        kernel.While_copy(original)(cond, body)
+    def copy(original: Tree)(elems: List[Term], tpt: TypeTree)(implicit ctx: Context): Repeated =
+      kernel.Repeated_copy(original)(elems, tpt)
 
-      /** Extractor for while loops. Matches `while (<cond>) <body>` and returns (<cond>, <body>) */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)] =
-        kernel.matchWhile(tree).map(x => (x.cond, x.body))
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Term], TypeTree)] =
+      kernel.matchRepeated(tree).map(x => (x.elems, x.elemtpt))
 
-    }
   }
 
-  implicit class IdentAPI(self: Term.Ident) {
-    def name(implicit ctx: Context): String = kernel.Ident_name(self)
+  implicit class RepeatedAPI(self: Repeated) {
+    def elems(implicit ctx: Context): List[Term] = kernel.Repeated_elems(self)
+    def elemtpt(implicit ctx: Context): TypeTree = kernel.Repeated_elemtpt(self)
   }
 
-  implicit class SelectAPI(self: Term.Select) {
-    def qualifier(implicit ctx: Context): Term = kernel.Select_qualifier(self)
-    def name(implicit ctx: Context): String = kernel.Select_name(self)
-    def signature(implicit ctx: Context): Option[Signature] = kernel.Select_signature(self)
+  object IsInlined {
+    /** Matches any Inlined and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Inlined] = kernel.matchInlined(tree)
   }
 
-  implicit class LiteralAPI(self: Term.Literal) {
-    def constant(implicit ctx: Context): Constant = kernel.Literal_constant(self)
-  }
+  object Inlined {
 
-  implicit class ThisAPI(self: Term.This) {
-    def id(implicit ctx: Context): Option[Id] = kernel.This_id(self)
-  }
+    def apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+      kernel.Inlined_apply(call, bindings, expansion)
 
-  implicit class NewAPI(self: Term.New) {
-    def tpt(implicit ctx: Context): TypeTree = kernel.New_tpt(self)
-  }
+    def copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+      kernel.Inlined_copy(original)(call, bindings, expansion)
 
-  implicit class NamedArgAPI(self: Term.NamedArg) {
-    def name(implicit ctx: Context): String = kernel.NamedArg_name(self)
-    def value(implicit ctx: Context): Term = kernel.NamedArg_value(self)
-  }
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[Tree /* Term | TypeTree */], List[Definition], Term)] =
+      kernel.matchInlined(tree).map(x => (x.call, x.bindings, x.body))
 
-  implicit class ApplyAPI(self: Term.Apply) {
-    def fun(implicit ctx: Context): Term = kernel.Apply_fun(self)
-    def args(implicit ctx: Context): List[Term] = kernel.Apply_args(self)
   }
 
-  implicit class TypeApplyAPI(self: Term.TypeApply) {
-    def fun(implicit ctx: Context): Term = kernel.TypeApply_fun(self)
-    def args(implicit ctx: Context): List[TypeTree] = kernel.TypeApply_args(self)
+  implicit class InlinedAPI(self: Inlined) {
+    def call(implicit ctx: Context): Option[Tree /* Term | TypeTree */] = kernel.Inlined_call(self)
+    def bindings(implicit ctx: Context): List[Definition] = kernel.Inlined_bindings(self)
+    def body(implicit ctx: Context): Term = kernel.Inlined_body(self)
   }
 
-  implicit class SuperAPI(self: Term.Super) {
-    def qualifier(implicit ctx: Context): Term = kernel.Super_qualifier(self)
-    def id(implicit ctx: Context): Option[Id] = kernel.Super_id(self)
+  object IsSelectOuter {
+    /** Matches any SelectOuter and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[SelectOuter] = kernel.matchSelectOuter(tree)
   }
 
-  implicit class TypedAPI(self: Term.Typed) {
-    def expr(implicit ctx: Context): Term = kernel.Typed_expr(self)
-    def tpt(implicit ctx: Context): TypeTree = kernel.Typed_tpt(self)
-  }
+  object SelectOuter {
 
-  implicit class AssignAPI(self: Term.Assign) {
-    def lhs(implicit ctx: Context): Term = kernel.Assign_lhs(self)
-    def rhs(implicit ctx: Context): Term = kernel.Assign_rhs(self)
-  }
+    def apply(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter =
+      kernel.SelectOuter_apply(qualifier, name, levels)
 
-  implicit class BlockAPI(self: Term.Block) {
-    def statements(implicit ctx: Context): List[Statement] = kernel.Block_statements(self)
-    def expr(implicit ctx: Context): Term = kernel.Block_expr(self)
-  }
+    def copy(original: Tree)(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter =
+      kernel.SelectOuter_copy(original)(qualifier, name, levels)
 
-  implicit class LambdaAPI(self: Term.Lambda) {
-    def meth(implicit ctx: Context): Term = kernel.Lambda_meth(self)
-    def tptOpt(implicit ctx: Context): Option[TypeTree] = kernel.Lambda_tptOpt(self)
-  }
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Int, Type)] = // TODO homogenize order of parameters
+      kernel.matchSelectOuter(tree).map(x => (x.qualifier, x.level, x.tpe))
 
-  implicit class IfAPI(self: Term.If) {
-    def cond(implicit ctx: Context): Term = kernel.If_cond(self)
-    def thenp(implicit ctx: Context): Term = kernel.If_thenp(self)
-    def elsep(implicit ctx: Context): Term = kernel.If_elsep(self)
   }
 
-  implicit class MatchAPI(self: Term.Match) {
-    def scrutinee(implicit ctx: Context): Term = kernel.Match_scrutinee(self)
-    def cases(implicit ctx: Context): List[CaseDef] = kernel.Match_cases(self)
+  implicit class SelectOuterAPI(self: SelectOuter) {
+    def qualifier(implicit ctx: Context): Term = kernel.SelectOuter_qualifier(self)
+    def level(implicit ctx: Context): Int = kernel.SelectOuter_level(self)
+    def tpe(implicit ctx: Context): Type = kernel.SelectOuter_tpe(self)
   }
 
-  implicit class ImplicitMatchAPI(self: Term.ImplicitMatch) {
-    def cases(implicit ctx: Context): List[CaseDef] = kernel.ImplicitMatch_cases(self)
+  object IsWhile {
+    /** Matches any While and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[While] = kernel.matchWhile(tree)
   }
 
-  implicit class TryAPI(self: Term.Try) {
-    def body(implicit ctx: Context): Term = kernel.Try_body(self)
-    def cases(implicit ctx: Context): List[CaseDef] = kernel.Try_cases(self)
-    def finalizer(implicit ctx: Context): Option[Term] = kernel.Try_finalizer(self)
-  }
+  object While {
 
-  implicit class ReturnAPI(self: Term.Return) {
-    def expr(implicit ctx: Context): Term = kernel.Return_expr(self)
-  }
+    /** Creates a while loop `while (<cond>) <body>` and returns (<cond>, <body>) */
+    def apply(cond: Term, body: Term)(implicit ctx: Context): While =
+      kernel.While_apply(cond, body)
 
-  implicit class RepeatedAPI(self: Term.Repeated) {
-    def elems(implicit ctx: Context): List[Term] = kernel.Repeated_elems(self)
-    def elemtpt(implicit ctx: Context): TypeTree = kernel.Repeated_elemtpt(self)
-  }
+    def copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While =
+      kernel.While_copy(original)(cond, body)
 
-  implicit class InlinedAPI(self: Term.Inlined) {
-    def call(implicit ctx: Context): Option[Tree /* Term | TypeTree */] = kernel.Inlined_call(self)
-    def bindings(implicit ctx: Context): List[Definition] = kernel.Inlined_bindings(self)
-    def body(implicit ctx: Context): Term = kernel.Inlined_body(self)
-  }
+    /** Extractor for while loops. Matches `while (<cond>) <body>` and returns (<cond>, <body>) */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)] =
+      kernel.matchWhile(tree).map(x => (x.cond, x.body))
 
-  implicit class SelectOuterAPI(self: Term.SelectOuter) {
-    def qualifier(implicit ctx: Context): Term = kernel.SelectOuter_qualifier(self)
-    def level(implicit ctx: Context): Int = kernel.SelectOuter_level(self)
-    def tpe(implicit ctx: Context): Type = kernel.SelectOuter_tpe(self)
   }
 
-  implicit class WhileAPI(self: Term.While) {
+  implicit class WhileAPI(self: While) {
     def cond(implicit ctx: Context): Term = kernel.While_cond(self)
     def body(implicit ctx: Context): Term = kernel.While_body(self)
   }
@@ -776,254 +772,251 @@ trait TreeOps extends Core {
       kernel.matchTypeTree(tpt)
   }
 
-  object TypeTree extends TypeTreeCoreModule {
-
-    object IsInferred {
-      /** Matches any Inferred and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Inferred] =
-        kernel.matchInferred(tree)
-    }
-
-    /** TypeTree containing an inferred type */
-    object Inferred {
-      def apply(tpe: Type)(implicit ctx: Context): Inferred =
-        kernel.Inferred_apply(tpe)
-      /** Matches a TypeTree containing an inferred type */
-      def unapply(tree: Tree)(implicit ctx: Context): Boolean =
-        kernel.matchInferred(tree).isDefined
-    }
-
-    object IsTypeIdent {
-      /** Matches any TypeIdent and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeIdent] =
-        kernel.matchTypeIdent(tree)
-    }
-
-    object TypeIdent {
-      // TODO def apply(name: String)(implicit ctx: Context): TypeIdent
-      def copy(original: TypeIdent)(name: String)(implicit ctx: Context): TypeIdent =
-        kernel.TypeIdent_copy(original)(name)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[String] =
-        kernel.matchTypeIdent(tree).map(_.name)
-    }
-
-    object IsTypeSelect {
-      /** Matches any TypeSelect and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeSelect] =
-        kernel.matchTypeSelect(tree)
-    }
-
-    object TypeSelect {
-      def apply(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect =
-        kernel.TypeSelect_apply(qualifier, name)
-      def copy(original: TypeSelect)(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect =
-        kernel.TypeSelect_copy(original)(qualifier, name)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] =
-        kernel.matchTypeSelect(tree).map(x => (x.qualifier, x.name))
-    }
-
-    object IsProjection {
-      /** Matches any Projection and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Projection] =
-        kernel.matchProjection(tree)
-    }
-
-    object Projection {
-      // TODO def apply(qualifier: TypeTree, name: String)(implicit ctx: Context): Project
-      def copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection =
-        kernel.Projection_copy(original)(qualifier, name)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, String)] =
-        kernel.matchProjection(tree).map(x => (x.qualifier, x.name))
-    }
-
-    object IsSingleton {
-      /** Matches any Singleton and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Singleton] =
-        kernel.matchSingleton(tree)
-    }
-
-    object Singleton {
-      def apply(ref: Term)(implicit ctx: Context): Singleton =
-        kernel.Singleton_apply(ref)
-      def copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton =
-        kernel.Singleton_copy(original)(ref)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
-        kernel.matchSingleton(tree).map(_.ref)
-    }
-
-    object IsRefined {
-      /** Matches any Refined and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Refined] =
-        kernel.matchRefined(tree)
-    }
-
-    object Refined {
-      // TODO def apply(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined
-      def copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined =
-        kernel.Refined_copy(original)(tpt, refinements)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Definition])] =
-        kernel.matchRefined(tree).map(x => (x.tpt, x.refinements))
-    }
-
-    object IsApplied {
-      /** Matches any Applied and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Applied] =
-        kernel.matchApplied(tree)
-    }
-
-    object Applied {
-      def apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): Applied =
-        kernel.Applied_apply(tpt, args)
-      def copy(original: Applied)(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): Applied =
-        kernel.Applied_copy(original)(tpt, args)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Tree /*TypeTree | TypeBoundsTree*/])] =
-        kernel.matchApplied(tree).map(x => (x.tpt, x.args))
-    }
-
-    object IsAnnotated {
-      /** Matches any Annotated and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Annotated] =
-        kernel.matchAnnotated(tree)
-    }
-
-    object Annotated {
-      def apply(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated =
-        kernel.Annotated_apply(arg, annotation)
-      def copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated =
-        kernel.Annotated_copy(original)(arg, annotation)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, Term)] =
-        kernel.matchAnnotated(tree).map(x => (x.arg, x.annotation))
-    }
-
-    object IsMatchTypeTree {
-      /** Matches any MatchTypeTree and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[MatchTypeTree] =
-        kernel.matchMatchTypeTree(tree)
-    }
-
-    object MatchTypeTree {
-      def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree =
-        kernel.MatchTypeTree_apply(bound, selector, cases)
-      def copy(original: MatchTypeTree)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree =
-        kernel.MatchTypeTree_copy(original)(bound, selector, cases)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])] =
-        kernel.matchMatchTypeTree(tree).map(x => (x.bound, x.selector, x.cases))
-    }
-
-    object IsByName {
-      /** Matches any ByName and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[ByName] =
-        kernel.matchByName(tree)
-    }
-
-    object ByName {
-      def apply(result: TypeTree)(implicit ctx: Context): ByName =
-        kernel.ByName_apply(result)
-      def copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName =
-        kernel.ByName_copy(original)(result)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] =
-        kernel.matchByName(tree).map(_.result)
-    }
-
-    object IsLambdaTypeTree {
-      /** Matches any LambdaTypeTree and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree] =
-        kernel.matchLambdaTypeTree(tree)
-    }
-
-    object LambdaTypeTree {
-      def apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): LambdaTypeTree =
-        kernel.Lambdaapply(tparams, body)
-      def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): LambdaTypeTree =
-        kernel.Lambdacopy(original)(tparams, body)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], Tree /*TypeTree | TypeBoundsTree*/)] =
-        kernel.matchLambdaTypeTree(tree).map(x => (x.tparams, x.body))
-    }
-
-    object IsTypeBind {
-      /** Matches any TypeBind and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBind] =
-        kernel.matchTypeBind(tree)
-    }
-
-    object TypeBind {
-      // TODO def apply(name: String, tree: Tree)(implicit ctx: Context): TypeBind
-      def copy(original: TypeBind)(name: String, tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeBind =
-        kernel.TypeBind_copy(original)(name, tpt)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Tree /*TypeTree | TypeBoundsTree*/)] =
-        kernel.matchTypeBind(tree).map(x => (x.name, x.body))
-    }
-
-    object IsTypeBlock {
-      /** Matches any TypeBlock and returns it */
-      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBlock] =
-        kernel.matchTypeBlock(tree)
-    }
-
-    object TypeBlock {
-      def apply(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock =
-        kernel.TypeBlock_apply(aliases, tpt)
-      def copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock =
-        kernel.TypeBlock_copy(original)(aliases, tpt)
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)] =
-        kernel.matchTypeBlock(tree).map(x => (x.aliases, x.tpt))
-    }
-  }
-
-  implicit class TypeIdentAPI(self: TypeTree.TypeIdent) {
+  object IsInferred {
+    /** Matches any Inferred and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Inferred] =
+      kernel.matchInferred(tree)
+  }
+
+  /** TypeTree containing an inferred type */
+  object Inferred {
+    def apply(tpe: Type)(implicit ctx: Context): Inferred =
+      kernel.Inferred_apply(tpe)
+    /** Matches a TypeTree containing an inferred type */
+    def unapply(tree: Tree)(implicit ctx: Context): Boolean =
+      kernel.matchInferred(tree).isDefined
+  }
+
+  object IsTypeIdent {
+    /** Matches any TypeIdent and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeIdent] =
+      kernel.matchTypeIdent(tree)
+  }
+
+  implicit class TypeIdentAPI(self: TypeIdent) {
     def name(implicit ctx: Context): String = kernel.TypeIdent_name(self)
   }
 
-  implicit class TypeSelectAPI(self: TypeTree.TypeSelect) {
+  object TypeIdent {
+    // TODO def apply(name: String)(implicit ctx: Context): TypeIdent
+    def copy(original: TypeIdent)(name: String)(implicit ctx: Context): TypeIdent =
+      kernel.TypeIdent_copy(original)(name)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[String] =
+      kernel.matchTypeIdent(tree).map(_.name)
+  }
+
+  object IsTypeSelect {
+    /** Matches any TypeSelect and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeSelect] =
+      kernel.matchTypeSelect(tree)
+  }
+
+  object TypeSelect {
+    def apply(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect =
+      kernel.TypeSelect_apply(qualifier, name)
+    def copy(original: TypeSelect)(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect =
+      kernel.TypeSelect_copy(original)(qualifier, name)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)] =
+      kernel.matchTypeSelect(tree).map(x => (x.qualifier, x.name))
+  }
+
+  implicit class TypeSelectAPI(self: TypeSelect) {
     def qualifier(implicit ctx: Context): Term = kernel.TypeSelect_qualifier(self)
     def name(implicit ctx: Context): String = kernel.TypeSelect_name(self)
   }
 
-  implicit class ProjectionAPI(self: TypeTree.Projection) {
+  object IsProjection {
+    /** Matches any Projection and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Projection] =
+      kernel.matchProjection(tree)
+  }
+
+  object Projection {
+    // TODO def apply(qualifier: TypeTree, name: String)(implicit ctx: Context): Project
+    def copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection =
+      kernel.Projection_copy(original)(qualifier, name)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, String)] =
+      kernel.matchProjection(tree).map(x => (x.qualifier, x.name))
+  }
+
+  implicit class ProjectionAPI(self: Projection) {
     def qualifier(implicit ctx: Context): TypeTree = kernel.Projection_qualifier(self)
     def name(implicit ctx: Context): String = kernel.Projection_name(self)
   }
 
-  implicit class SingletonAPI(self: TypeTree.Singleton) {
+  object IsSingleton {
+    /** Matches any Singleton and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Singleton] =
+      kernel.matchSingleton(tree)
+  }
+
+  object Singleton {
+    def apply(ref: Term)(implicit ctx: Context): Singleton =
+      kernel.Singleton_apply(ref)
+    def copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton =
+      kernel.Singleton_copy(original)(ref)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
+      kernel.matchSingleton(tree).map(_.ref)
+  }
+
+  implicit class SingletonAPI(self: Singleton) {
     def ref(implicit ctx: Context): Term = kernel.Singleton_ref(self)
   }
 
-  implicit class RefinedAPI(self: TypeTree.Refined) {
+  object IsRefined {
+    /** Matches any Refined and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Refined] =
+      kernel.matchRefined(tree)
+  }
+
+  object Refined {
+    // TODO def apply(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined
+    def copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined =
+      kernel.Refined_copy(original)(tpt, refinements)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Definition])] =
+      kernel.matchRefined(tree).map(x => (x.tpt, x.refinements))
+  }
+
+  implicit class RefinedAPI(self: Refined) {
     def tpt(implicit ctx: Context): TypeTree = kernel.Refined_tpt(self)
     def refinements(implicit ctx: Context): List[Definition] = kernel.Refined_refinements(self)
   }
 
-  implicit class AppliedAPI(self: TypeTree.Applied) {
+  object IsApplied {
+    /** Matches any Applied and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Applied] =
+      kernel.matchApplied(tree)
+  }
+
+  object Applied {
+    def apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): Applied =
+      kernel.Applied_apply(tpt, args)
+    def copy(original: Applied)(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(implicit ctx: Context): Applied =
+      kernel.Applied_copy(original)(tpt, args)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Tree /*TypeTree | TypeBoundsTree*/])] =
+      kernel.matchApplied(tree).map(x => (x.tpt, x.args))
+  }
+
+  implicit class AppliedAPI(self: Applied) {
     def tpt(implicit ctx: Context): TypeTree = kernel.Applied_tpt(self)
     def args(implicit ctx: Context): List[Tree /*TypeTree | TypeBoundsTree*/] = kernel.Applied_args(self)
   }
 
-  implicit class AnnotatedAPI(self: TypeTree.Annotated) {
+  object IsAnnotated {
+    /** Matches any Annotated and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Annotated] =
+      kernel.matchAnnotated(tree)
+  }
+
+  object Annotated {
+    def apply(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated =
+      kernel.Annotated_apply(arg, annotation)
+    def copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated =
+      kernel.Annotated_copy(original)(arg, annotation)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, Term)] =
+      kernel.matchAnnotated(tree).map(x => (x.arg, x.annotation))
+  }
+
+  implicit class AnnotatedAPI(self: Annotated) {
     def arg(implicit ctx: Context): TypeTree = kernel.Annotated_arg(self)
     def annotation(implicit ctx: Context): Term = kernel.Annotated_annotation(self)
   }
 
-  implicit class MatchTypeTreeAPI(self: TypeTree.MatchTypeTree) {
+  object IsMatchTypeTree {
+    /** Matches any MatchTypeTree and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[MatchTypeTree] =
+      kernel.matchMatchTypeTree(tree)
+  }
+
+  object MatchTypeTree {
+    def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree =
+      kernel.MatchTypeTree_apply(bound, selector, cases)
+    def copy(original: MatchTypeTree)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree =
+      kernel.MatchTypeTree_copy(original)(bound, selector, cases)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])] =
+      kernel.matchMatchTypeTree(tree).map(x => (x.bound, x.selector, x.cases))
+  }
+
+  implicit class MatchTypeTreeAPI(self: MatchTypeTree) {
     def bound(implicit ctx: Context): Option[TypeTree] = kernel.MatchTypeTree_bound(self)
     def selector(implicit ctx: Context): TypeTree = kernel.MatchTypeTree_selector(self)
     def cases(implicit ctx: Context): List[TypeCaseDef] = kernel.MatchTypeTree_cases(self)
   }
 
-  implicit class ByNameAPI(self: TypeTree.ByName) {
+  object IsByName {
+    /** Matches any ByName and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[ByName] =
+      kernel.matchByName(tree)
+  }
+
+  object ByName {
+    def apply(result: TypeTree)(implicit ctx: Context): ByName =
+      kernel.ByName_apply(result)
+    def copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName =
+      kernel.ByName_copy(original)(result)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree] =
+      kernel.matchByName(tree).map(_.result)
+  }
+
+  implicit class ByNameAPI(self: ByName) {
     def result(implicit ctx: Context): TypeTree = kernel.ByName_result(self)
   }
 
-  implicit class LambdaTypeTreeAPI(self: TypeTree.LambdaTypeTree) {
+  object IsLambdaTypeTree {
+    /** Matches any LambdaTypeTree and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree] =
+      kernel.matchLambdaTypeTree(tree)
+  }
+
+  object LambdaTypeTree {
+    def apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): LambdaTypeTree =
+      kernel.Lambdaapply(tparams, body)
+    def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): LambdaTypeTree =
+      kernel.Lambdacopy(original)(tparams, body)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], Tree /*TypeTree | TypeBoundsTree*/)] =
+      kernel.matchLambdaTypeTree(tree).map(x => (x.tparams, x.body))
+  }
+
+  implicit class LambdaTypeTreeAPI(self: LambdaTypeTree) {
     def tparams(implicit ctx: Context): List[TypeDef] = kernel.Lambdatparams(self)
     def body(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = kernel.Lambdabody(self)
   }
 
-  implicit class TypeBindAPI(self: TypeTree.TypeBind) {
+  object IsTypeBind {
+    /** Matches any TypeBind and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBind] =
+      kernel.matchTypeBind(tree)
+  }
+
+  object TypeBind {
+    // TODO def apply(name: String, tree: Tree)(implicit ctx: Context): TypeBind
+    def copy(original: TypeBind)(name: String, tpt: Tree /*TypeTree | TypeBoundsTree*/)(implicit ctx: Context): TypeBind =
+      kernel.TypeBind_copy(original)(name, tpt)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Tree /*TypeTree | TypeBoundsTree*/)] =
+      kernel.matchTypeBind(tree).map(x => (x.name, x.body))
+  }
+
+  implicit class TypeBindAPI(self: TypeBind) {
     def name(implicit ctx: Context): String = kernel.TypeBind_name(self)
     def body(implicit ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = kernel.TypeBind_body(self)
   }
 
-  implicit class TypeBlockAPI(self: TypeTree.TypeBlock) {
+  object IsTypeBlock {
+    /** Matches any TypeBlock and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBlock] =
+      kernel.matchTypeBlock(tree)
+  }
+
+  object TypeBlock {
+    def apply(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock =
+      kernel.TypeBlock_apply(aliases, tpt)
+    def copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock =
+      kernel.TypeBlock_copy(original)(aliases, tpt)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)] =
+      kernel.matchTypeBlock(tree).map(x => (x.aliases, x.tpt))
+  }
+
+  implicit class TypeBlockAPI(self: TypeBlock) {
     def aliases(implicit ctx: Context): List[TypeDef] = kernel.TypeBlock_aliases(self)
     def tpt(implicit ctx: Context): TypeTree = kernel.TypeBlock_tpt(self)
   }
diff --git a/library/src/scala/tasty/reflect/TreeUtils.scala b/library/src/scala/tasty/reflect/TreeUtils.scala
index 50de53632cad..e67a2158af8f 100644
--- a/library/src/scala/tasty/reflect/TreeUtils.scala
+++ b/library/src/scala/tasty/reflect/TreeUtils.scala
@@ -20,44 +20,44 @@ trait TreeUtils
     def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
       def localCtx(definition: Definition): Context = definition.symbol.localContext
       tree match {
-        case Term.Ident(_) =>
+        case Ident(_) =>
           x
-        case Term.Select(qualifier, _) =>
+        case Select(qualifier, _) =>
           foldTree(x, qualifier)
-        case Term.This(qual) =>
+        case This(qual) =>
           x
-        case Term.Super(qual, _) =>
+        case Super(qual, _) =>
           foldTree(x, qual)
-        case Term.Apply(fun, args) =>
+        case Apply(fun, args) =>
           foldTrees(foldTree(x, fun), args)
-        case Term.TypeApply(fun, args) =>
+        case TypeApply(fun, args) =>
           foldTrees(foldTree(x, fun), args)
-        case Term.Literal(const) =>
+        case Literal(const) =>
           x
-        case Term.New(tpt) =>
+        case New(tpt) =>
           foldTree(x, tpt)
-        case Term.Typed(expr, tpt) =>
+        case Typed(expr, tpt) =>
           foldTree(foldTree(x, expr), tpt)
-        case Term.NamedArg(_, arg) =>
+        case NamedArg(_, arg) =>
           foldTree(x, arg)
-        case Term.Assign(lhs, rhs) =>
+        case Assign(lhs, rhs) =>
           foldTree(foldTree(x, lhs), rhs)
-        case Term.Block(stats, expr) =>
+        case Block(stats, expr) =>
           foldTree(foldTrees(x, stats), expr)
-        case Term.If(cond, thenp, elsep) =>
+        case If(cond, thenp, elsep) =>
           foldTree(foldTree(foldTree(x, cond), thenp), elsep)
-        case Term.Lambda(meth, tpt) =>
+        case Lambda(meth, tpt) =>
           val a = foldTree(x, meth)
           tpt.fold(a)(b => foldTree(a, b))
-        case Term.Match(selector, cases) =>
+        case Match(selector, cases) =>
           foldTrees(foldTree(x, selector), cases)
-        case Term.Return(expr) =>
+        case Return(expr) =>
           foldTree(x, expr)
-        case Term.Try(block, handler, finalizer) =>
+        case Try(block, handler, finalizer) =>
           foldTrees(foldTrees(foldTree(x, block), handler), finalizer)
-        case Term.Repeated(elems, elemtpt) =>
+        case Repeated(elems, elemtpt) =>
           foldTrees(foldTree(x, elemtpt), elems)
-        case Term.Inlined(call, bindings, expansion) =>
+        case Inlined(call, bindings, expansion) =>
           foldTree(foldTrees(x, bindings), expansion)
         case IsDefinition(vdef @ ValDef(_, tpt, rhs)) =>
           implicit val ctx = localCtx(vdef)
@@ -75,19 +75,19 @@ trait TreeUtils
           foldTree(x, expr)
         case IsPackageClause(clause @ PackageClause(pid, stats)) =>
           foldTrees(foldTree(x, pid), stats)(clause.symbol.localContext)
-        case TypeTree.Inferred() => x
-        case TypeTree.TypeIdent(_) => x
-        case TypeTree.TypeSelect(qualifier, _) => foldTree(x, qualifier)
-        case TypeTree.Projection(qualifier, _) => foldTree(x, qualifier)
-        case TypeTree.Singleton(ref) => foldTree(x, ref)
-        case TypeTree.Refined(tpt, refinements) => foldTrees(foldTree(x, tpt), refinements)
-        case TypeTree.Applied(tpt, args) => foldTrees(foldTree(x, tpt), args)
-        case TypeTree.ByName(result) => foldTree(x, result)
-        case TypeTree.Annotated(arg, annot) => foldTree(foldTree(x, arg), annot)
-        case TypeTree.LambdaTypeTree(typedefs, arg) => foldTree(foldTrees(x, typedefs), arg)
-        case TypeTree.TypeBind(_, tbt) => foldTree(x, tbt)
-        case TypeTree.TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs), tpt)
-        case TypeTree.MatchTypeTree(boundopt, selector, cases) =>
+        case Inferred() => x
+        case TypeIdent(_) => x
+        case TypeSelect(qualifier, _) => foldTree(x, qualifier)
+        case Projection(qualifier, _) => foldTree(x, qualifier)
+        case Singleton(ref) => foldTree(x, ref)
+        case Refined(tpt, refinements) => foldTrees(foldTree(x, tpt), refinements)
+        case Applied(tpt, args) => foldTrees(foldTree(x, tpt), args)
+        case ByName(result) => foldTree(x, result)
+        case Annotated(arg, annot) => foldTree(foldTree(x, arg), annot)
+        case LambdaTypeTree(typedefs, arg) => foldTree(foldTrees(x, typedefs), arg)
+        case TypeBind(_, tbt) => foldTree(x, tbt)
+        case TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs), tpt)
+        case MatchTypeTree(boundopt, selector, cases) =>
           foldTrees(foldTree(boundopt.fold(x)(foldTree(x, _)), selector), cases)
         case WildcardTypeTree() => x
         case TypeBoundsTree(lo, hi) => foldTree(foldTree(x, lo), hi)
@@ -124,7 +124,7 @@ trait TreeUtils
     def transformTree(tree: Tree)(implicit ctx: Context): Tree = {
       tree match {
         case IsPackageClause(tree) =>
-          PackageClause.copy(tree)(transformTerm(tree.pid).asInstanceOf[Term.Ref], transformTrees(tree.stats)(tree.symbol.localContext))
+          PackageClause.copy(tree)(transformTerm(tree.pid).asInstanceOf[Ref], transformTrees(tree.stats)(tree.symbol.localContext))
         case IsImport(tree) =>
           Import.copy(tree)(tree.importImplied, transformTerm(tree.expr), tree.selectors)
         case IsStatement(tree) =>
@@ -164,74 +164,74 @@ trait TreeUtils
 
     def transformTerm(tree: Term)(implicit ctx: Context): Term = {
       tree match {
-        case Term.Ident(name) =>
+        case Ident(name) =>
           tree
-        case Term.Select(qualifier, name) =>
-          Term.Select.copy(tree)(transformTerm(qualifier), name)
-        case Term.This(qual) =>
+        case Select(qualifier, name) =>
+          Select.copy(tree)(transformTerm(qualifier), name)
+        case This(qual) =>
           tree
-        case Term.Super(qual, mix) =>
-          Term.Super.copy(tree)(transformTerm(qual), mix)
-        case Term.Apply(fun, args) =>
-          Term.Apply.copy(tree)(transformTerm(fun), transformTerms(args))
-        case Term.TypeApply(fun, args) =>
-          Term.TypeApply.copy(tree)(transformTerm(fun), transformTypeTrees(args))
-        case Term.Literal(const) =>
+        case Super(qual, mix) =>
+          Super.copy(tree)(transformTerm(qual), mix)
+        case Apply(fun, args) =>
+          Apply.copy(tree)(transformTerm(fun), transformTerms(args))
+        case TypeApply(fun, args) =>
+          TypeApply.copy(tree)(transformTerm(fun), transformTypeTrees(args))
+        case Literal(const) =>
           tree
-        case Term.New(tpt) =>
-          Term.New.copy(tree)(transformTypeTree(tpt))
-        case Term.Typed(expr, tpt) =>
-          Term.Typed.copy(tree)(transformTerm(expr), transformTypeTree(tpt))
-        case Term.IsNamedArg(tree) =>
-          Term.NamedArg.copy(tree)(tree.name, transformTerm(tree.value))
-        case Term.Assign(lhs, rhs) =>
-          Term.Assign.copy(tree)(transformTerm(lhs), transformTerm(rhs))
-        case Term.Block(stats, expr) =>
-          Term.Block.copy(tree)(transformStats(stats), transformTerm(expr))
-        case Term.If(cond, thenp, elsep) =>
-          Term.If.copy(tree)(transformTerm(cond), transformTerm(thenp), transformTerm(elsep))
-        case Term.Lambda(meth, tpt) =>
-          Term.Lambda.copy(tree)(transformTerm(meth), tpt.map(x => transformTypeTree(x)))
-        case Term.Match(selector, cases) =>
-          Term.Match.copy(tree)(transformTerm(selector), transformCaseDefs(cases))
-        case Term.Return(expr) =>
-          Term.Return.copy(tree)(transformTerm(expr))
-        case Term.While(cond, body) =>
-          Term.While.copy(tree)(transformTerm(cond), transformTerm(body))
-        case Term.Try(block, cases, finalizer) =>
-          Term.Try.copy(tree)(transformTerm(block), transformCaseDefs(cases), finalizer.map(x => transformTerm(x)))
-        case Term.Repeated(elems, elemtpt) =>
-          Term.Repeated.copy(tree)(transformTerms(elems), transformTypeTree(elemtpt))
-        case Term.Inlined(call, bindings, expansion) =>
-          Term.Inlined.copy(tree)(call, transformSubTrees(bindings), transformTerm(expansion)/*()call.symbol.localContext)*/)
+        case New(tpt) =>
+          New.copy(tree)(transformTypeTree(tpt))
+        case Typed(expr, tpt) =>
+          Typed.copy(tree)(transformTerm(expr), transformTypeTree(tpt))
+        case IsNamedArg(tree) =>
+          NamedArg.copy(tree)(tree.name, transformTerm(tree.value))
+        case Assign(lhs, rhs) =>
+          Assign.copy(tree)(transformTerm(lhs), transformTerm(rhs))
+        case Block(stats, expr) =>
+          Block.copy(tree)(transformStats(stats), transformTerm(expr))
+        case If(cond, thenp, elsep) =>
+          If.copy(tree)(transformTerm(cond), transformTerm(thenp), transformTerm(elsep))
+        case Lambda(meth, tpt) =>
+          Lambda.copy(tree)(transformTerm(meth), tpt.map(x => transformTypeTree(x)))
+        case Match(selector, cases) =>
+          Match.copy(tree)(transformTerm(selector), transformCaseDefs(cases))
+        case Return(expr) =>
+          Return.copy(tree)(transformTerm(expr))
+        case While(cond, body) =>
+          While.copy(tree)(transformTerm(cond), transformTerm(body))
+        case Try(block, cases, finalizer) =>
+          Try.copy(tree)(transformTerm(block), transformCaseDefs(cases), finalizer.map(x => transformTerm(x)))
+        case Repeated(elems, elemtpt) =>
+          Repeated.copy(tree)(transformTerms(elems), transformTypeTree(elemtpt))
+        case Inlined(call, bindings, expansion) =>
+          Inlined.copy(tree)(call, transformSubTrees(bindings), transformTerm(expansion)/*()call.symbol.localContext)*/)
       }
     }
 
     def transformTypeTree(tree: TypeTree)(implicit ctx: Context): TypeTree = tree match {
-      case TypeTree.Inferred() => tree
-      case TypeTree.IsTypeIdent(tree) => tree
-      case TypeTree.IsTypeSelect(tree) =>
-        TypeTree.TypeSelect.copy(tree)(tree.qualifier, tree.name)
-      case TypeTree.IsProjection(tree) =>
-        TypeTree.Projection.copy(tree)(tree.qualifier, tree.name)
-      case TypeTree.IsAnnotated(tree) =>
-        TypeTree.Annotated.copy(tree)(tree.arg, tree.annotation)
-      case TypeTree.IsSingleton(tree) =>
-        TypeTree.Singleton.copy(tree)(transformTerm(tree.ref))
-      case TypeTree.IsRefined(tree) =>
-        TypeTree.Refined.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.refinements).asInstanceOf[List[Definition]])
-      case TypeTree.IsApplied(tree) =>
-        TypeTree.Applied.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.args))
-      case TypeTree.IsMatchTypeTree(tree) =>
-        TypeTree.MatchTypeTree.copy(tree)(tree.bound.map(b => transformTypeTree(b)), transformTypeTree(tree.selector), transformTypeCaseDefs(tree.cases))
-      case TypeTree.IsByName(tree) =>
-        TypeTree.ByName.copy(tree)(transformTypeTree(tree.result))
-      case TypeTree.IsLambdaTypeTree(tree) =>
-        TypeTree.LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams), transformTree(tree.body))(tree.symbol.localContext)
-      case TypeTree.IsTypeBind(tree) =>
-        TypeTree.TypeBind.copy(tree)(tree.name, tree.body)
-      case TypeTree.IsTypeBlock(tree) =>
-        TypeTree.TypeBlock.copy(tree)(tree.aliases, tree.tpt)
+      case Inferred() => tree
+      case IsTypeIdent(tree) => tree
+      case IsTypeSelect(tree) =>
+        TypeSelect.copy(tree)(tree.qualifier, tree.name)
+      case IsProjection(tree) =>
+        Projection.copy(tree)(tree.qualifier, tree.name)
+      case IsAnnotated(tree) =>
+        Annotated.copy(tree)(tree.arg, tree.annotation)
+      case IsSingleton(tree) =>
+        Singleton.copy(tree)(transformTerm(tree.ref))
+      case IsRefined(tree) =>
+        Refined.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.refinements).asInstanceOf[List[Definition]])
+      case IsApplied(tree) =>
+        Applied.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.args))
+      case IsMatchTypeTree(tree) =>
+        MatchTypeTree.copy(tree)(tree.bound.map(b => transformTypeTree(b)), transformTypeTree(tree.selector), transformTypeCaseDefs(tree.cases))
+      case IsByName(tree) =>
+        ByName.copy(tree)(transformTypeTree(tree.result))
+      case IsLambdaTypeTree(tree) =>
+        LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams), transformTree(tree.body))(tree.symbol.localContext)
+      case IsTypeBind(tree) =>
+        TypeBind.copy(tree)(tree.name, tree.body)
+      case IsTypeBlock(tree) =>
+        TypeBlock.copy(tree)(tree.aliases, tree.tpt)
     }
 
     def transformCaseDef(tree: CaseDef)(implicit ctx: Context): CaseDef = {
diff --git a/library/src/scala/tasty/util/ConstantExtractor.scala b/library/src/scala/tasty/util/ConstantExtractor.scala
index b4fb7294c090..0ce44288e629 100644
--- a/library/src/scala/tasty/util/ConstantExtractor.scala
+++ b/library/src/scala/tasty/util/ConstantExtractor.scala
@@ -20,9 +20,9 @@ class ConstantExtractor[R <: Reflection with Singleton](val reflect: Reflection)
 
   def unapply[T](expr: Expr[T]): Option[T] = {
     def const(tree: Term): Option[T] = tree match {
-      case Term.Literal(c) => Some(c.value.asInstanceOf[T])
-      case Term.Block(Nil, e) => const(e)
-      case Term.Inlined(_, Nil, e) => const(e)
+      case Literal(c) => Some(c.value.asInstanceOf[T])
+      case Block(Nil, e) => const(e)
+      case Inlined(_, Nil, e) => const(e)
       case _  => None
     }
     const(expr.unseal)
diff --git a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala
index 9402ea7006e1..87ca647b2a86 100644
--- a/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala
+++ b/semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala
@@ -596,11 +596,11 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
 
       def getImportPath(pathTerm: Term): String = {
         val range = pathTerm match {
-          case Term.Select(qualifier, selected) => {
+          case Select(qualifier, selected) => {
             getImportPath(qualifier)
             rangeSelect(selected, pathTerm.pos)
           }
-          case Term.Ident(x) => {
+          case Ident(x) => {
             createRange(pathTerm.pos.startLine, pathTerm.pos.startColumn, pathTerm.symbol.trueName.length)
           }
         }
@@ -634,13 +634,13 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
       def traverseTypeTree(tree: Tree /*TypeTree | TypeBoundsTree*/)(
           implicit ctx: Context): Unit = {
         tree match {
-          case TypeTree.TypeIdent(_) => {
+          case TypeIdent(_) => {
             val typetree = tree.typetree
             addOccurenceTypeTree(typetree,
                                  s.SymbolOccurrence.Role.REFERENCE,
                                  createRange(typetree.pos))
           }
-          case TypeTree.TypeSelect(qualifier, _) => {
+          case TypeSelect(qualifier, _) => {
             val typetree = tree.typetree
             val range = rangeSelect(typetree.symbol.trueName, typetree.pos)
             addOccurenceTypeTree(typetree,
@@ -649,7 +649,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
             super.traverseTree(typetree)
           }
 
-          case TypeTree.Projection(qualifier, x) => {
+          case Projection(qualifier, x) => {
               val typetree = tree.typetree
               val range = rangeSelect(typetree.symbol.trueName, typetree.pos)
               addOccurenceTypeTree(typetree,
@@ -658,7 +658,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
               super.traverseTree(typetree)
           }
 
-          case TypeTree.Inferred() => {
+          case Inferred() => {
             /* In theory no inferred types should be put in the semanticdb file.
             However, take the case where a typed is refered from an imported class:
               class PrefC {
@@ -750,10 +750,10 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
               packageDefinitions += key
               getImportSelectors(getImportPath(path), selectors)
             }
-          case Term.New(ty) => {
+          case New(ty) => {
             super.traverseTree(tree)
           }
-          case Term.Apply(_, _) => {
+          case Apply(_, _) => {
             super.traverseTree(tree)
           }
           case ClassDef(classname, constr, parents, derived, selfopt, statements) => {
@@ -875,7 +875,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
           case DefDef("<init>", _, _, _, _) if tree.symbol.owner.flags.is(Flags.Object) => {
           }
 
-          case Term.Assign(lhs, rhs) => {
+          case Assign(lhs, rhs) => {
             // We make sure to set [isAssignedTerm] to true on the lhs
             isAssignedTerm = true
             traverseTree(lhs)
@@ -929,7 +929,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
             super.traverseTree(cdef)
           }
 
-          case Term.This(Some(id)) => {
+          case This(Some(id)) => {
             /* We've got two options here:
             - either the this is explicit: eg C.this.XXX. In this case, the position is [C.this], but
               we want to put the symbol on the C, so around id
@@ -946,14 +946,14 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
                              rangeThis)
           }
 
-          case Term.Super(_, Some(id)) => {
+          case Super(_, Some(id)) => {
             addOccurence(classStacks.head,
               s.SymbolOccurrence.Role.DEFINITION,
               createRange(id.pos))
             super.traverseTree(tree)
           }
 
-          case Term.Select(qualifier, _) => {
+          case Select(qualifier, _) => {
             var range = rangeSelect(tree.symbol.trueName, tree.pos)
 
             /* This branch deals with select of a `this`. Their is two options:
@@ -985,7 +985,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
             addOccurenceTree(tree, s.SymbolOccurrence.Role.REFERENCE, range, shouldForceAdd, isMutableAssignement)
           }
 
-          case Term.Ident(name) => {
+          case Ident(name) => {
             addOccurenceTree(tree,
                              s.SymbolOccurrence.Role.REFERENCE,
                              createRange(tree.pos.startLine, tree.pos.startColumn, tree.symbol.trueName.length))
@@ -993,7 +993,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
             super.traverseTree(tree)
           }
 
-          case Term.Inlined(Some(c), b, d) => {
+          case Inlined(Some(c), b, d) => {
             /* In theory files should be compiled with -Yno-inline before running semanticdb.
             If this is not the case, here is a fallback to heuristically determine which predefFunction
             corresponds to an inlined term.
diff --git a/semanticdb/src/dotty/semanticdb/TastyScalaFileInferrer.scala b/semanticdb/src/dotty/semanticdb/TastyScalaFileInferrer.scala
index 15b13a41404d..d5e86bd8cd64 100644
--- a/semanticdb/src/dotty/semanticdb/TastyScalaFileInferrer.scala
+++ b/semanticdb/src/dotty/semanticdb/TastyScalaFileInferrer.scala
@@ -23,8 +23,8 @@ class TastyScalaFileInferrer extends TastyConsumer {
           case IsClassDef(cdef) => {
             cdef.symbol.annots.foreach { annot =>
               annot match {
-                case Term.Apply(Term.Select(Term.New(t), _),
-                                List(Term.Literal(Constant.String(path))))
+                case Apply(Select(New(t), _),
+                                List(Literal(Constant.String(path))))
                     if t.symbol.name == "SourceFile" =>
                   // we found the path to a file. In this case, we do not need to
                   // continue traversing the tree
diff --git a/tests/neg-with-compiler/i5941/macro_1.scala b/tests/neg-with-compiler/i5941/macro_1.scala
index 4791335569a5..5ce1f4ab267e 100644
--- a/tests/neg-with-compiler/i5941/macro_1.scala
+++ b/tests/neg-with-compiler/i5941/macro_1.scala
@@ -19,15 +19,15 @@ object Lens {
 
     // obj.copy(field = value)
     def setterBody(obj: Expr[S], value: Expr[T], field: String): Expr[S] =
-      Term.Select.overloaded(obj.unseal, "copy", Nil, Term.NamedArg(field, value.unseal) :: Nil).seal[S]
+      Select.overloaded(obj.unseal, "copy", Nil, NamedArg(field, value.unseal) :: Nil).seal[S]
 
     // exception: getter.unseal.underlyingArgument
     getter.unseal match {
-      case Term.Inlined(
+      case Inlined(
         None, Nil,
-        Term.Block(
-          DefDef(_, Nil, (param :: Nil) :: Nil, _, Some(Term.Select(o, field))) :: Nil,
-          Term.Lambda(meth, _)
+        Block(
+          DefDef(_, Nil, (param :: Nil) :: Nil, _, Some(Select(o, field))) :: Nil,
+          Lambda(meth, _)
         )
       ) if o.symbol == param.symbol =>
         '{
diff --git a/tests/neg/tasty-macro-assert-1/quoted_1.scala b/tests/neg/tasty-macro-assert-1/quoted_1.scala
index b52a238bd41b..4e5aeb372348 100644
--- a/tests/neg/tasty-macro-assert-1/quoted_1.scala
+++ b/tests/neg/tasty-macro-assert-1/quoted_1.scala
@@ -26,14 +26,14 @@ object Asserts {
 
     object OpsTree {
       def unapply(arg: Term): Option[Term] = arg match {
-        case Term.Apply(Term.TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
+        case Apply(TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
           Some(left)
         case _ => None
       }
     }
 
     tree match {
-      case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
+      case Inlined(_, Nil, Apply(Select(OpsTree(left), op), right :: Nil)) =>
         '{assertTrue(${left.seal[Boolean]})} // Buggy code. To generate the errors
       case _ =>
         '{assertTrue($cond)}
diff --git a/tests/neg/tasty-macro-assert-2/quoted_1.scala b/tests/neg/tasty-macro-assert-2/quoted_1.scala
index 34afc5800a0f..8c6cad74969a 100644
--- a/tests/neg/tasty-macro-assert-2/quoted_1.scala
+++ b/tests/neg/tasty-macro-assert-2/quoted_1.scala
@@ -26,14 +26,14 @@ object Asserts {
 
     object OpsTree {
       def unapply(arg: Term): Option[Term] = arg match {
-        case Term.Apply(Term.TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
+        case Apply(TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
           Some(left)
         case _ => None
       }
     }
 
     tree match {
-      case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
+      case Inlined(_, Nil, Apply(Select(OpsTree(left), op), right :: Nil)) =>
         '{assertTrue(${left.seal[Boolean]})} // Buggy code. To generate the errors
       case _ =>
         '{assertTrue($cond)}
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check b/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check
index 299dbdade381..f40fe6a19705 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check
@@ -1,3 +1,3 @@
-DefDef("foo", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+"), List(Term.Literal(Constant.Int(2))))))
-ValDef("bar", TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+"), List(Term.Literal(Constant.Int(3))))))
-Pattern.Bind("x", Pattern.Value(Term.Ident("_")))
+DefDef("foo", Nil, Nil, TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(1)), "+"), List(Literal(Constant.Int(2))))))
+ValDef("bar", TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(2)), "+"), List(Literal(Constant.Int(3))))))
+Pattern.Bind("x", Pattern.Value(Ident("_")))
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
index 1c03f7351e2c..7f054b1fe9da 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
@@ -14,7 +14,7 @@ object Foo {
       case IsBindSymbol(sym) => sym.tree.show.toExpr
     }
     x.unseal match {
-      case Term.Inlined(None, Nil, arg) => definitionString(arg)
+      case Inlined(None, Nil, arg) => definitionString(arg)
       case arg => definitionString(arg) // TODO should all by name parameters be in an inline node?
     }
   }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check b/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check
index 466e73606bac..d1962c3dcc9d 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check
@@ -1,3 +1,3 @@
-DefDef("foo", Nil, Nil, TypeTree.Inferred(), None)
-ValDef("bar", TypeTree.Inferred(), None)
-Pattern.Bind("x", Pattern.Value(Term.Ident("_")))
+DefDef("foo", Nil, Nil, Inferred(), None)
+ValDef("bar", Inferred(), None)
+Pattern.Bind("x", Pattern.Value(Ident("_")))
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
index c667717d07a2..3e26fccaefcc 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
@@ -14,7 +14,7 @@ object Foo {
       case IsBindSymbol(sym) => sym.tree.show.toExpr
     }
     x.unseal match {
-      case Term.Inlined(None, Nil, arg) => definitionString(arg)
+      case Inlined(None, Nil, arg) => definitionString(arg)
       case arg => definitionString(arg) // TODO should all by name parameters be in an inline node?
     }
   }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check
index e2d34376e9a5..9a374aedf3b4 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check
@@ -1,27 +1,27 @@
 foo
-DefDef("main", Nil, List(List(ValDef("args", TypeTree.Inferred(), None))), TypeTree.Inferred(), None)
+DefDef("main", Nil, List(List(ValDef("args", Inferred(), None))), Inferred(), None)
 
 bar
-DefDef("foo", Nil, Nil, TypeTree.Inferred(), None)
+DefDef("foo", Nil, Nil, Inferred(), None)
 
 bar2
-DefDef("foo", Nil, Nil, TypeTree.Inferred(), None)
+DefDef("foo", Nil, Nil, Inferred(), None)
 
 foo2
-DefDef("main", Nil, List(List(ValDef("args", TypeTree.Inferred(), None))), TypeTree.Inferred(), None)
+DefDef("main", Nil, List(List(ValDef("args", Inferred(), None))), Inferred(), None)
 
 baz
-ValDef("foo2", TypeTree.Inferred(), None)
+ValDef("foo2", Inferred(), None)
 
 baz2
-ValDef("foo2", TypeTree.Inferred(), None)
+ValDef("foo2", Inferred(), None)
 
 <init>
-ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(TypeTree.Inferred()), Nil, None, List(TypeDef("B", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred())), DefDef("b", Nil, Nil, TypeTree.Inferred(), None), ValDef("b2", TypeTree.Inferred(), None)))
+ClassDef("A", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Inferred()), Nil, None, List(TypeDef("B", TypeBoundsTree(Inferred(), Inferred())), DefDef("b", Nil, Nil, Inferred(), None), ValDef("b2", Inferred(), None)))
 
 b
-ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(TypeTree.Inferred()), Nil, None, List(TypeDef("B", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred())), DefDef("b", Nil, Nil, TypeTree.Inferred(), None), ValDef("b2", TypeTree.Inferred(), None)))
+ClassDef("A", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Inferred()), Nil, None, List(TypeDef("B", TypeBoundsTree(Inferred(), Inferred())), DefDef("b", Nil, Nil, Inferred(), None), ValDef("b2", Inferred(), None)))
 
 b2
-ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(TypeTree.Inferred()), Nil, None, List(TypeDef("B", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred())), DefDef("b", Nil, Nil, TypeTree.Inferred(), None), ValDef("b2", TypeTree.Inferred(), None)))
+ClassDef("A", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Inferred()), Nil, None, List(TypeDef("B", TypeBoundsTree(Inferred(), Inferred())), DefDef("b", Nil, Nil, Inferred(), None), ValDef("b2", Inferred(), None)))
 
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1.check b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1.check
index 3f3af8dda9f9..335a80717346 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1.check
@@ -1,2 +1,2 @@
-DefDef("foo", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+"), List(Term.Literal(Constant.Int(2))))))
-ValDef("bar", TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+"), List(Term.Literal(Constant.Int(3))))))
+DefDef("foo", Nil, Nil, TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(1)), "+"), List(Literal(Constant.Int(2))))))
+ValDef("bar", TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(2)), "+"), List(Literal(Constant.Int(3))))))
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
index 2bb11a418d83..af0c1b393961 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
@@ -18,7 +18,7 @@ object Foo {
     }
 
     x.unseal match {
-      case Term.Inlined(None, Nil, arg) => definitionString(arg)
+      case Inlined(None, Nil, arg) => definitionString(arg)
       case arg => definitionString(arg) // TODO should all by name parameters be in an inline node
     }
   }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2.check b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2.check
index 6438ecc51781..6030480e8861 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2.check
@@ -1,2 +1,2 @@
-DefDef("foo", Nil, Nil, TypeTree.Inferred(), None)
-ValDef("bar", TypeTree.Inferred(), None)
+DefDef("foo", Nil, Nil, Inferred(), None)
+ValDef("bar", Inferred(), None)
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
index 1047d81a75ef..3019372e91e6 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
@@ -18,7 +18,7 @@ object Foo {
     }
 
     x.unseal match {
-      case Term.Inlined(None, Nil, arg) => definitionString(arg)
+      case Inlined(None, Nil, arg) => definitionString(arg)
       case arg => definitionString(arg) // TODO should all by name parameters be in an inline node
     }
   }
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
index 3a737a9fdb5c..f48093443e3b 100644
--- a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
+++ b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
@@ -35,7 +35,7 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
 
   def interpretCall(fn: Term, argss: List[List[Term]]): Result = {
     fn match {
-      case Term.Select (prefix, _) =>
+      case Select (prefix, _) =>
         val pre = eval (prefix)
         // TODO use
       case _ =>
@@ -107,11 +107,11 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
     tree match {
       case Call(fn, targs, argss) =>
         fn match {
-          case Term.Select(_, "<init>") =>  log("interpretNew", tree)(interpretNew(fn, argss))
-          case Term.Select(prefix, "isInstanceOf") => log("interpretIsInstanceOf", tree)(interpretIsInstanceOf(eval(prefix), targs.head))
-          case Term.Select(prefix, "asInstanceOf") => log("interpretAsInstanceOf", tree)(interpretAsInstanceOf(eval(prefix), targs.head))
-          case Term.Select(prefix, "==") => log("interpretEqEq", tree)(interpretEqEq(eval(prefix), eval(argss.head.head)))
-          case Term.Select(prefix, name @ ("+" | "-" | "*" | "<" | ">" | "<=" | "=>")) if isNumericPrimitive(prefix.tpe) =>
+          case Select(_, "<init>") =>  log("interpretNew", tree)(interpretNew(fn, argss))
+          case Select(prefix, "isInstanceOf") => log("interpretIsInstanceOf", tree)(interpretIsInstanceOf(eval(prefix), targs.head))
+          case Select(prefix, "asInstanceOf") => log("interpretAsInstanceOf", tree)(interpretAsInstanceOf(eval(prefix), targs.head))
+          case Select(prefix, "==") => log("interpretEqEq", tree)(interpretEqEq(eval(prefix), eval(argss.head.head)))
+          case Select(prefix, name @ ("+" | "-" | "*" | "<" | ">" | "<=" | "=>")) if isNumericPrimitive(prefix.tpe) =>
             val lhs = eval(prefix)
             val rhs = eval(argss.head.head)
             name match {
@@ -123,12 +123,12 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
               case "<=" => log("interpretPrivitiveLtEq", tree)(interpretPrivitiveLtEq(lhs, rhs))
               case ">=" => log("interpretPrivitiveGtEq", tree)(interpretPrivitiveGtEq(lhs, rhs))
             }
-          case Term.Select(prefix, name @ ("/" | "%")) if isIntegralPrimitive(prefix.tpe) =>
+          case Select(prefix, name @ ("/" | "%")) if isIntegralPrimitive(prefix.tpe) =>
             def lhs = eval(prefix)
             def rhs = eval(argss.head.head)
             if (name == "/") log("interpretPrivitiveQuot", tree)(interpretPrivitiveQuot(lhs, rhs))
             else log("interpretPrivitiveRem", tree)(interpretPrivitiveRem(lhs, rhs))
-          case Term.Select(prefix, name @ "/") if isFractionalPrimitive(prefix.tpe) =>
+          case Select(prefix, name @ "/") if isFractionalPrimitive(prefix.tpe) =>
             def lhs = eval(prefix)
             def rhs = eval(argss.head.head)
             log("interpretPrivitiveDiv", tree)(interpretPrivitiveDiv(lhs, rhs))
@@ -142,15 +142,15 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
             }
         }
 
-      case Term.Assign(lhs, rhs) =>
+      case Assign(lhs, rhs) =>
         log("<interpretAssing>", tree)(localValue(lhs.symbol).update(eval(rhs)))
 
-      case Term.If(cond, thenp, elsep) => log("interpretIf", tree)(interpretIf(cond, thenp, elsep))
-      case Term.While(cond, body)      => log("interpretWhile", tree)(interpretWhile(cond, body))
-      case Term.Block(stats, expr)     => log("interpretBlock", tree)(interpretBlock(stats, expr))
-      case Term.Literal(const)         => log("interpretLiteral", tree)(interpretLiteral(const))
-      case Term.Typed(expr, _)         => log("<interpretTyped>", tree)(eval(expr))
-      case Term.Repeated(elems, _)     => log("<interpretRepeated>", tree)(interpretRepeated(elems.map(elem => eval(elem))))
+      case If(cond, thenp, elsep) => log("interpretIf", tree)(interpretIf(cond, thenp, elsep))
+      case While(cond, body)      => log("interpretWhile", tree)(interpretWhile(cond, body))
+      case Block(stats, expr)     => log("interpretBlock", tree)(interpretBlock(stats, expr))
+      case Literal(const)         => log("interpretLiteral", tree)(interpretLiteral(const))
+      case Typed(expr, _)         => log("<interpretTyped>", tree)(eval(expr))
+      case Repeated(elems, _)     => log("<interpretRepeated>", tree)(interpretRepeated(elems.map(elem => eval(elem))))
 
       case _ => throw new MatchError(tree.show)
     }
@@ -206,10 +206,10 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
 
   private object Call {
     def unapply(arg: Tree): Option[(Term, List[TypeTree], List[List[Term]])] = arg match {
-      case Term.IsSelect(fn) => Some((fn, Nil, Nil))
-      case Term.IsIdent(fn) => Some((fn, Nil, Nil))
-      case Term.Apply(Call(fn, targs, args1), args2) => Some((fn, targs, args1 :+ args2))
-      case Term.TypeApply(Call(fn, _, _), targs) => Some((fn, targs, Nil))
+      case IsSelect(fn) => Some((fn, Nil, Nil))
+      case IsIdent(fn) => Some((fn, Nil, Nil))
+      case Apply(Call(fn, targs, args1), args2) => Some((fn, targs, args1 :+ args2))
+      case TypeApply(Call(fn, _, _), targs) => Some((fn, targs, Nil))
       case _ => None
     }
   }
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
index 5a974fe1b0e6..4a85695f6a39 100644
--- a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
+++ b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
@@ -55,7 +55,7 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
     if (fn.symbol.isDefinedInCurrentRun) super.interpretCall(fn, argss)
     else {
       fn match {
-        case Term.Select(prefix, _) =>
+        case Select(prefix, _) =>
           val IsDefDefSymbol(sym) = fn.symbol
           val pre = eval(prefix).asInstanceOf[Object]
           val argss2 = evaluatedArgss(argss)
@@ -71,7 +71,6 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
   override def interpretValGet(fn: Term): Result = {
     if (fn.symbol.isDefinedInCurrentRun) super.interpretValGet(fn)
     else {
-      import Term._
       fn match {
         case Select(prefix, _) =>
           // FIXME not necesarly static
diff --git a/tests/run-with-compiler/i5715/Macro_1.scala b/tests/run-with-compiler/i5715/Macro_1.scala
index 7a3811e5fd8a..e2bc9941c735 100644
--- a/tests/run-with-compiler/i5715/Macro_1.scala
+++ b/tests/run-with-compiler/i5715/Macro_1.scala
@@ -9,9 +9,9 @@ object scalatest {
     import refl._
 
     cond.unseal.underlyingArgument match {
-      case app @ Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
-        val Term.IsSelect(select) = sel
-        val cond = Term.Apply(Term.Select.copy(select)(lhs, "exists"), rhs :: Nil).seal[Boolean]
+      case app @ Apply(sel @ Select(lhs, op), rhs :: Nil) =>
+        val IsSelect(select) = sel
+        val cond = Apply(Select.copy(select)(lhs, "exists"), rhs :: Nil).seal[Boolean]
         '{ scala.Predef.assert($cond) }
       case _ =>
         '{ scala.Predef.assert($cond) }
diff --git a/tests/run-with-compiler/i5941/macro_1.scala b/tests/run-with-compiler/i5941/macro_1.scala
index 6eed35a2a69c..02a713ee7b93 100644
--- a/tests/run-with-compiler/i5941/macro_1.scala
+++ b/tests/run-with-compiler/i5941/macro_1.scala
@@ -22,19 +22,19 @@ object Lens {
     def setterBody(obj: Term, value: Term, parts: List[String]): Term = {
       // o.copy(field = value)
       def helper(obj: Term, value: Term, field: String): Term =
-        Term.Select.overloaded(obj, "copy", Nil, Term.NamedArg(field, value) :: Nil)
+        Select.overloaded(obj, "copy", Nil, NamedArg(field, value) :: Nil)
 
       parts match {
         case field :: Nil => helper(obj, value, field)
         case field :: parts =>
-          helper(obj, setterBody(Term.Select.unique(obj, field), value, parts), field)
+          helper(obj, setterBody(Select.unique(obj, field), value, parts), field)
       }
     }
 
     object Path {
       private def recur(tree: Term, selects: List[String]): Option[(Term, List[String])] = tree match {
-        case Term.Ident(_) if selects.nonEmpty => Some((tree, selects))
-        case Term.Select(qual, name) => recur(qual, name :: selects)
+        case Ident(_) if selects.nonEmpty => Some((tree, selects))
+        case Select(qual, name) => recur(qual, name :: selects)
         case _ => None
       }
 
@@ -43,11 +43,11 @@ object Lens {
 
     object Function {
       def unapply(t: Term): Option[(List[ValDef], Term)] = t match {
-        case Term.Inlined(
+        case Inlined(
           None, Nil,
-          Term.Block(
+          Block(
             (ddef @ DefDef(_, Nil, params :: Nil, _, Some(body))) :: Nil,
-            Term.Lambda(meth, _)
+            Lambda(meth, _)
           )
         ) if meth.symbol == ddef.symbol => Some((params, body))
         case _ => None
@@ -122,9 +122,9 @@ object Iso {
 
     '{
       // (p: S) => p._1
-      val to = (p: S) =>  ${ Term.Select.unique(('p).unseal, "_1").seal[A] }
+      val to = (p: S) =>  ${ Select.unique(('p).unseal, "_1").seal[A] }
       // (p: A) => S(p)
-      val from = (p: A) =>  ${ Term.Select.overloaded(Term.Ident(companion), "apply", Nil, ('p).unseal :: Nil).seal[S] }
+      val from = (p: A) =>  ${ Select.overloaded(Ident(companion), "apply", Nil, ('p).unseal :: Nil).seal[S] }
       apply(from)(to)
     }
   }
@@ -137,7 +137,7 @@ object Iso {
     val tpS = typeOf[S]
 
     if (tpS.isSingleton) {
-      val ident = Term.Ident(tpS.asInstanceOf[TermRef]).seal[S]
+      val ident = Ident(tpS.asInstanceOf[TermRef]).seal[S]
       '{
         Iso[S, 1](Function.const($ident))(Function.const(1))
       }
@@ -153,7 +153,7 @@ object Iso {
         case Type.TypeRef(name, prefix) => Type.TermRef(prefix, name)
       }
 
-      val obj = Term.Select.overloaded(Term.Ident(companion), "apply", Nil, Nil).seal[S]
+      val obj = Select.overloaded(Ident(companion), "apply", Nil, Nil).seal[S]
 
       '{
         Iso[S, 1](Function.const($obj))(Function.const(1))
diff --git a/tests/run-with-compiler/i6171/Macro_1.scala b/tests/run-with-compiler/i6171/Macro_1.scala
index 32af57d0f558..6fdd0f680f45 100644
--- a/tests/run-with-compiler/i6171/Macro_1.scala
+++ b/tests/run-with-compiler/i6171/Macro_1.scala
@@ -13,10 +13,10 @@ object scalatest {
     def isImplicitMethodType(tp: Type): Boolean =
       Type.IsMethodType.unapply(tp).flatMap(tp => if tp.isImplicit then Some(true) else None).nonEmpty
     cond.unseal.underlyingArgument match {
-      case t @ Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Term.Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil)
             let(app) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
@@ -26,12 +26,12 @@ object scalatest {
             }
           }
         }.seal[Unit]
-      case Term.Apply(f @ Term.Apply(Term.Select(Term.Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
+      case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
         if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil)
-            let(Term.Apply(app, implicits)) { result =>
+            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            let(Apply(app, implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
diff --git a/tests/run-with-compiler/reflect-select-constructor/assert_1.scala b/tests/run-with-compiler/reflect-select-constructor/assert_1.scala
index 1a34880b00db..973433145c48 100644
--- a/tests/run-with-compiler/reflect-select-constructor/assert_1.scala
+++ b/tests/run-with-compiler/reflect-select-constructor/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
       Type.IsMethodType.unapply(tp).flatMap(tp => if tp.isImplicit then Some(true) else None).nonEmpty
 
     cond.unseal.underlyingArgument match {
-      case t @ Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Term.Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil)
             let(app) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
@@ -27,12 +27,12 @@ object scalatest {
             }
           }
         }.seal[Unit]
-      case Term.Apply(f @ Term.Apply(Term.Select(Term.Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
+      case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil)
-            let(Term.Apply(app, implicits)) { result =>
+            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            let(Apply(app, implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
diff --git a/tests/run-with-compiler/reflect-select-copy/assert_1.scala b/tests/run-with-compiler/reflect-select-copy/assert_1.scala
index 7b11c5a55ecb..98e56cd51d29 100644
--- a/tests/run-with-compiler/reflect-select-copy/assert_1.scala
+++ b/tests/run-with-compiler/reflect-select-copy/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
       Type.IsMethodType.unapply(tp).flatMap(tp => if tp.isImplicit then Some(true) else None).nonEmpty
 
     cond.unseal.underlyingArgument match {
-      case Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
+      case Apply(sel @ Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            let(Term.Apply(Term.Select.copy(sel)(left, op), right :: Nil)) { result =>
+            let(Apply(Select.copy(sel)(left, op), right :: Nil)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
@@ -26,11 +26,11 @@ object scalatest {
             }
           }
         }.seal[Unit]
-      case Term.Apply(f @ Term.Apply(Term.IsSelect(sel @ Term.Select(Term.Apply(qual, lhs :: Nil), op)), rhs :: Nil), implicits)
+      case Apply(f @ Apply(IsSelect(sel @ Select(Apply(qual, lhs :: Nil), op)), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            let(Term.Apply(Term.Apply(Term.Select.copy(sel)(Term.Apply(qual, left :: Nil), op), right :: Nil), implicits)) { result =>
+            let(Apply(Apply(Select.copy(sel)(Apply(qual, left :: Nil), op), right :: Nil), implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
diff --git a/tests/run-with-compiler/reflect-select-value-class/assert_1.scala b/tests/run-with-compiler/reflect-select-value-class/assert_1.scala
index 1a34880b00db..973433145c48 100644
--- a/tests/run-with-compiler/reflect-select-value-class/assert_1.scala
+++ b/tests/run-with-compiler/reflect-select-value-class/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
       Type.IsMethodType.unapply(tp).flatMap(tp => if tp.isImplicit then Some(true) else None).nonEmpty
 
     cond.unseal.underlyingArgument match {
-      case t @ Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Term.Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil)
             let(app) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
@@ -27,12 +27,12 @@ object scalatest {
             }
           }
         }.seal[Unit]
-      case Term.Apply(f @ Term.Apply(Term.Select(Term.Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
+      case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil)
-            let(Term.Apply(app, implicits)) { result =>
+            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            let(Apply(app, implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
diff --git a/tests/run-with-compiler/tasty-consumer.check b/tests/run-with-compiler/tasty-consumer.check
index 9be2bf328868..04a1ecf43c56 100644
--- a/tests/run-with-compiler/tasty-consumer.check
+++ b/tests/run-with-compiler/tasty-consumer.check
@@ -1,5 +1,5 @@
-ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("foo", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(2)))), DefDef("bar", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))))
-DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None)
-ValDef("foo", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(2))))
-DefDef("bar", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))
-ValDef("i", TypeTree.TypeIdent("Int"), None)
+ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("foo", TypeIdent("Int"), Some(Literal(Constant.Int(2)))), DefDef("bar", Nil, List(List(ValDef("i", TypeIdent("Int"), None))), TypeIdent("Int"), Some(Literal(Constant.Int(3))))))
+DefDef("<init>", Nil, List(Nil), Inferred(), None)
+ValDef("foo", TypeIdent("Int"), Some(Literal(Constant.Int(2))))
+DefDef("bar", Nil, List(List(ValDef("i", TypeIdent("Int"), None))), TypeIdent("Int"), Some(Literal(Constant.Int(3))))
+ValDef("i", TypeIdent("Int"), None)
diff --git a/tests/run/f-interpolation-1/FQuote_1.scala b/tests/run/f-interpolation-1/FQuote_1.scala
index e65c48adc772..f5e19d18bdc3 100644
--- a/tests/run/f-interpolation-1/FQuote_1.scala
+++ b/tests/run/f-interpolation-1/FQuote_1.scala
@@ -21,7 +21,7 @@ object FQuote {
     }
 
     def isStringConstant(tree: Term) = tree match {
-      case Term.Literal(_) => true
+      case Literal(_) => true
       case _ => false
     }
 
@@ -33,17 +33,17 @@ object FQuote {
 
     // FQuote.SCOps(StringContext.apply([p0, ...]: String*)
     val parts = receiver.unseal.underlyingArgument match {
-      case Term.Apply(conv, List(Term.Apply(fun, List(Term.Typed(Term.Repeated(values, _), _)))))
+      case Apply(conv, List(Apply(fun, List(Typed(Repeated(values, _), _)))))
           if isSCOpsConversion(conv) &&
              isStringContextApply(fun) &&
              values.forall(isStringConstant) =>
-        values.collect { case Term.Literal(Constant.String(value)) => value }
+        values.collect { case Literal(Constant.String(value)) => value }
       case tree =>
         throw new QuoteError(s"String literal expected, but ${tree.show} found")
     }
 
     // [a0, ...]: Any*
-    val Term.Typed(Term.Repeated(allArgs, _), _) = args.unseal.underlyingArgument
+    val Typed(Repeated(allArgs, _), _) = args.unseal.underlyingArgument
 
     for ((arg, part) <- allArgs.zip(parts.tail)) {
       if (part.startsWith("%d") && !(arg.tpe <:< definitions.IntType)) {
diff --git a/tests/run/i5119.check b/tests/run/i5119.check
index b4a7f4d64db1..90c98e0a2c3b 100644
--- a/tests/run/i5119.check
+++ b/tests/run/i5119.check
@@ -1,2 +1,2 @@
-Term.Select(Term.Typed(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("StringContextOps")), "<init>"), List(Term.Apply(Term.Select(Term.Select(Term.Select(Term.Ident("_root_"), "scala"), "StringContext"), "apply"), List(Term.Typed(Term.Repeated(List(Term.Literal(Constant.String("Hello World ")), Term.Literal(Constant.String("!"))), TypeTree.Inferred()), TypeTree.Inferred()))))), TypeTree.TypeIdent("StringContextOps")), "inline$sc")
-Term.Typed(Term.Repeated(List(Term.Literal(Constant.Int(1))), TypeTree.Inferred()), TypeTree.Inferred())
+Select(Typed(Apply(Select(New(TypeIdent("StringContextOps")), "<init>"), List(Apply(Select(Select(Select(Ident("_root_"), "scala"), "StringContext"), "apply"), List(Typed(Repeated(List(Literal(Constant.String("Hello World ")), Literal(Constant.String("!"))), Inferred()), Inferred()))))), TypeIdent("StringContextOps")), "inline$sc")
+Typed(Repeated(List(Literal(Constant.Int(1))), Inferred()), Inferred())
diff --git a/tests/run/i5119b.check b/tests/run/i5119b.check
index 29e18e92d65b..3e1f5cde7707 100644
--- a/tests/run/i5119b.check
+++ b/tests/run/i5119b.check
@@ -1,4 +1,4 @@
-Term.Apply(Term.Ident("foo"), List(Term.Literal(Constant.Int(1))))
-Term.Apply(Term.Ident("foo"), List(Term.Literal(Constant.Int(2))))
-Term.Apply(Term.Ident("foo"), List(Term.Literal(Constant.Int(4))))
-Term.Apply(Term.Ident("foo"), List(Term.Literal(Constant.Int(3))))
+Apply(Ident("foo"), List(Literal(Constant.Int(1))))
+Apply(Ident("foo"), List(Literal(Constant.Int(2))))
+Apply(Ident("foo"), List(Literal(Constant.Int(4))))
+Apply(Ident("foo"), List(Literal(Constant.Int(3))))
diff --git a/tests/run/i5533b/Macro_1.scala b/tests/run/i5533b/Macro_1.scala
index 8c5afb167c15..6fe53256438e 100644
--- a/tests/run/i5533b/Macro_1.scala
+++ b/tests/run/i5533b/Macro_1.scala
@@ -15,7 +15,7 @@ object scalatest {
     def exprStr: String = condition.show
 
     tree.underlyingArgument match {
-      case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case Apply(Select(lhs, op), rhs :: Nil) =>
         val left = lhs.seal[Any]
         val right = rhs.seal[Any]
         op match {
diff --git a/tests/run/i5536/Macro_1.scala b/tests/run/i5536/Macro_1.scala
index 0fe7e9778637..936b928a0339 100644
--- a/tests/run/i5536/Macro_1.scala
+++ b/tests/run/i5536/Macro_1.scala
@@ -12,7 +12,7 @@ object scalatest {
     def exprStr: String = condition.show
 
     tree.underlyingArgument match {
-      case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case Apply(Select(lhs, op), rhs :: Nil) =>
         val left = lhs.seal[Any]
         val right = rhs.seal[Any]
         op match {
diff --git a/tests/run/reflect-select-copy/assert_1.scala b/tests/run/reflect-select-copy/assert_1.scala
index 56ef7d642d47..de2906675941 100644
--- a/tests/run/reflect-select-copy/assert_1.scala
+++ b/tests/run/reflect-select-copy/assert_1.scala
@@ -10,9 +10,9 @@ object scalatest {
     import quoted.Toolbox.Default._
 
     cond.unseal.underlyingArgument match {
-      case Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
-        val Term.IsSelect(select) = sel
-        val cond = Term.Apply(Term.Select.copy(select)(lhs, ">"), rhs :: Nil).seal[Boolean]
+      case Apply(sel @ Select(lhs, op), rhs :: Nil) =>
+        val IsSelect(select) = sel
+        val cond = Apply(Select.copy(select)(lhs, ">"), rhs :: Nil).seal[Boolean]
         '{ scala.Predef.assert($cond) }
       case _ =>
         '{ scala.Predef.assert($cond) }
diff --git a/tests/run/tasty-argument-tree-1.check b/tests/run/tasty-argument-tree-1.check
index fa0be0ec8113..e72a126900a5 100644
--- a/tests/run/tasty-argument-tree-1.check
+++ b/tests/run/tasty-argument-tree-1.check
@@ -1,42 +1,42 @@
 
-tree: Term.Inlined(None, Nil, Term.Literal(Constant.Int(3)))
-tree deref. vals: Term.Literal(Constant.Int(3))
+tree: Inlined(None, Nil, Literal(Constant.Int(3)))
+tree deref. vals: Literal(Constant.Int(3))
 
-tree: Term.Inlined(None, Nil, Term.Ident("v"))
-tree deref. vals: Term.Literal(Constant.Int(1))
+tree: Inlined(None, Nil, Ident("v"))
+tree deref. vals: Literal(Constant.Int(1))
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Literal(Constant.Int(2))
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Literal(Constant.Int(2))
 
-tree: Term.Inlined(None, Nil, Term.Ident("l"))
-tree deref. vals: Term.Literal(Constant.Int(3))
+tree: Inlined(None, Nil, Ident("l"))
+tree deref. vals: Literal(Constant.Int(3))
 
-tree: Term.Inlined(None, Nil, Term.Ident("a"))
-tree deref. vals: Term.Ident("a")
+tree: Inlined(None, Nil, Ident("a"))
+tree deref. vals: Ident("a")
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Ident("b")
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Ident("b")
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Apply(Term.Ident("d2"), Nil)
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Apply(Ident("d2"), Nil)
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Apply(Term.Ident("d3"), List(Term.Literal(Constant.Int(3))))
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Apply(Ident("d3"), List(Literal(Constant.Int(3))))
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.TypeApply(Term.Ident("d4"), List(TypeTree.TypeIdent("Int")))
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: TypeApply(Ident("d4"), List(TypeIdent("Int")))
 
-tree: Term.Inlined(None, Nil, Term.Ident("vv"))
-tree deref. vals: Term.Literal(Constant.Int(1))
+tree: Inlined(None, Nil, Ident("vv"))
+tree deref. vals: Literal(Constant.Int(1))
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Literal(Constant.Int(1))
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Literal(Constant.Int(1))
 
-tree: Term.Inlined(None, Nil, Term.Ident("vd"))
-tree deref. vals: Term.Literal(Constant.Int(2))
+tree: Inlined(None, Nil, Ident("vd"))
+tree deref. vals: Literal(Constant.Int(2))
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Literal(Constant.Int(2))
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Literal(Constant.Int(2))
 
-tree: Term.Inlined(None, Nil, Term.Ident("x"))
-tree deref. vals: Term.Apply(Term.TypeApply(Term.Select(Term.Ident("Tuple2"), "apply"), List(TypeTree.Inferred(), TypeTree.Inferred())), List(Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2))))
+tree: Inlined(None, Nil, Ident("x"))
+tree deref. vals: Apply(TypeApply(Select(Ident("Tuple2"), "apply"), List(Inferred(), Inferred())), List(Literal(Constant.Int(1)), Literal(Constant.Int(2))))
diff --git a/tests/run/tasty-extractors-1.check b/tests/run/tasty-extractors-1.check
index feaf2e1cc5f4..0b920ba33f1b 100644
--- a/tests/run/tasty-extractors-1.check
+++ b/tests/run/tasty-extractors-1.check
@@ -1,120 +1,120 @@
-Term.Inlined(None, Nil, Term.Literal(Constant.Boolean(true)))
+Inlined(None, Nil, Literal(Constant.Boolean(true)))
 Type.ConstantType(Constant.Boolean(true))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.Int(1)))
+Inlined(None, Nil, Literal(Constant.Int(1)))
 Type.ConstantType(Constant.Int(1))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.Long(2)))
+Inlined(None, Nil, Literal(Constant.Long(2)))
 Type.ConstantType(Constant.Long(2))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.Float(2.1)))
+Inlined(None, Nil, Literal(Constant.Float(2.1)))
 Type.ConstantType(Constant.Float(2.1))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.Double(2.2)))
+Inlined(None, Nil, Literal(Constant.Double(2.2)))
 Type.ConstantType(Constant.Double(2.2))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.String("abc")))
+Inlined(None, Nil, Literal(Constant.String("abc")))
 Type.ConstantType(Constant.String("abc"))
 
-Term.Inlined(None, Nil, Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.String("abc")))))
+Inlined(None, Nil, Apply(Ident("println"), List(Literal(Constant.String("abc")))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(8)), TypeTree.TypeIdent("Int")))
+Inlined(None, Nil, Typed(Literal(Constant.Int(8)), TypeIdent("Int")))
 Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Byte(8)), TypeTree.TypeIdent("Byte")))
+Inlined(None, Nil, Typed(Literal(Constant.Byte(8)), TypeIdent("Byte")))
 Type.SymRef(IsClassDefSymbol(<scala.Byte>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Short(8)), TypeTree.TypeIdent("Short")))
+Inlined(None, Nil, Typed(Literal(Constant.Short(8)), TypeIdent("Short")))
 Type.SymRef(IsClassDefSymbol(<scala.Short>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.Char(a)))
+Inlined(None, Nil, Literal(Constant.Char(a)))
 Type.ConstantType(Constant.Char(a))
 
-Term.Inlined(None, Nil, Term.Block(List(Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2))), Term.Literal(Constant.Int(3))))
+Inlined(None, Nil, Block(List(Literal(Constant.Int(1)), Literal(Constant.Int(2))), Literal(Constant.Int(3))))
 Type.ConstantType(Constant.Int(3))
 
-Term.Inlined(None, Nil, Term.If(Term.Typed(Term.Literal(Constant.Boolean(true)), TypeTree.TypeIdent("Boolean")), Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2))))
+Inlined(None, Nil, If(Typed(Literal(Constant.Boolean(true)), TypeIdent("Boolean")), Literal(Constant.Int(1)), Literal(Constant.Int(2))))
 Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("a")), List(CaseDef(Pattern.Value(Term.Literal(Constant.String("a"))), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Literal(Constant.String("a")), List(CaseDef(Pattern.Value(Literal(Constant.String("a"))), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("b")), List(CaseDef(Pattern.Bind("n", Pattern.Value(Term.Ident("_"))), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Literal(Constant.String("b")), List(CaseDef(Pattern.Bind("n", Pattern.Value(Ident("_"))), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("c")), List(CaseDef(Pattern.Bind("n", Pattern.TypeTest(TypeTree.TypeIdent("String"))), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Literal(Constant.String("c")), List(CaseDef(Pattern.Bind("n", Pattern.TypeTest(TypeIdent("String"))), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("e")), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Literal(Constant.String("e")), List(CaseDef(Pattern.Value(Ident("_")), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("f")), List(CaseDef(Pattern.TypeTest(TypeTree.TypeIdent("String")), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Literal(Constant.String("f")), List(CaseDef(Pattern.TypeTest(TypeIdent("String")), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Typed(Term.Literal(Constant.String("g")), TypeTree.TypeIdent("Any")), List(CaseDef(Pattern.Alternative(List(Pattern.TypeTest(TypeTree.TypeIdent("String")), Pattern.TypeTest(TypeTree.TypeIdent("Int")))), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Typed(Literal(Constant.String("g")), TypeIdent("Any")), List(CaseDef(Pattern.Alternative(List(Pattern.TypeTest(TypeIdent("String")), Pattern.TypeTest(TypeIdent("Int")))), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("h")), List(CaseDef(Pattern.Value(Term.Ident("_")), Some(Term.Literal(Constant.Boolean(false))), Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Literal(Constant.String("h")), List(CaseDef(Pattern.Value(Ident("_")), Some(Literal(Constant.Boolean(false))), Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ValDef("a", TypeTree.Inferred(), Some(Term.Literal(Constant.String("o"))))), Term.Match(Term.Literal(Constant.String("i")), List(CaseDef(Pattern.Bind("a", Pattern.Value(Term.Ident("_"))), None, Term.Block(Nil, Term.Literal(Constant.Unit())))))))
+Inlined(None, Nil, Block(List(ValDef("a", Inferred(), Some(Literal(Constant.String("o"))))), Match(Literal(Constant.String("i")), List(CaseDef(Pattern.Bind("a", Pattern.Value(Ident("_"))), None, Block(Nil, Literal(Constant.Unit())))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Match(Term.Ident("Nil"), List(CaseDef(Pattern.Unapply(Term.TypeApply(Term.Select(Term.Ident("List"), "unapplySeq"), List(TypeTree.Inferred())), Nil, List(Pattern.Bind("a", Pattern.Value(Term.Ident("_"))), Pattern.Bind("b", Pattern.Value(Term.Ident("_"))), Pattern.Bind("c", Pattern.Value(Term.Ident("_"))))), None, Term.Block(Nil, Term.Literal(Constant.Unit()))))))
+Inlined(None, Nil, Match(Ident("Nil"), List(CaseDef(Pattern.Unapply(TypeApply(Select(Ident("List"), "unapplySeq"), List(Inferred())), Nil, List(Pattern.Bind("a", Pattern.Value(Ident("_"))), Pattern.Bind("b", Pattern.Value(Ident("_"))), Pattern.Bind("c", Pattern.Value(Ident("_"))))), None, Block(Nil, Literal(Constant.Unit()))))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(1)), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Block(Nil, Term.Literal(Constant.Unit())))), None))
+Inlined(None, Nil, Try(Literal(Constant.Int(1)), List(CaseDef(Pattern.Value(Ident("_")), None, Block(Nil, Literal(Constant.Unit())))), None))
 Type.OrType(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))), Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(2)), Nil, Some(Term.Literal(Constant.Unit()))))
+Inlined(None, Nil, Try(Literal(Constant.Int(2)), Nil, Some(Literal(Constant.Unit()))))
 Type.ConstantType(Constant.Int(2))
 
-Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(3)), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Block(Nil, Term.Literal(Constant.Unit())))), Some(Term.Literal(Constant.Unit()))))
+Inlined(None, Nil, Try(Literal(Constant.Int(3)), List(CaseDef(Pattern.Value(Ident("_")), None, Block(Nil, Literal(Constant.Unit())))), Some(Literal(Constant.Unit()))))
 Type.OrType(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))), Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.Literal(Constant.String("a")), "=="), List(Term.Literal(Constant.String("b")))))
+Inlined(None, Nil, Apply(Select(Literal(Constant.String("a")), "=="), List(Literal(Constant.String("b")))))
 Type.SymRef(IsClassDefSymbol(<scala.Boolean>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Object")), "<init>"), Nil))
+Inlined(None, Nil, Apply(Select(New(TypeIdent("Object")), "<init>"), Nil))
 Type.SymRef(IsClassDefSymbol(<java.lang.Object>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<java.lang>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.Ident("Int"), "box"), List(Term.NamedArg("x", Term.Literal(Constant.Int(9))))))
+Inlined(None, Nil, Apply(Select(Ident("Int"), "box"), List(NamedArg("x", Literal(Constant.Int(9))))))
 Type.SymRef(IsClassDefSymbol(<java.lang.Integer>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<java.lang>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Apply(Term.TypeApply(Term.Select(Term.Ident("Ordering"), "apply"), List(TypeTree.TypeIdent("Int"))), List(Term.Ident("Int"))))
+Inlined(None, Nil, Apply(TypeApply(Select(Ident("Ordering"), "apply"), List(TypeIdent("Int"))), List(Ident("Int"))))
 Type.AppliedType(Type.SymRef(IsClassDefSymbol(<scala.math.Ordering>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala.math>), NoPrefix()))), List(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))))
 
-Term.Inlined(None, Nil, Term.Block(List(ValDef("a", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ValDef("a", TypeIdent("Int"), Some(Literal(Constant.Int(3))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ValDef("b", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ValDef("b", TypeIdent("Int"), Some(Literal(Constant.Int(3))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f1", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f1", Nil, Nil, TypeIdent("Int"), Some(Literal(Constant.Int(3))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f2", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Return(Term.Literal(Constant.Int(4)))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f2", Nil, Nil, TypeIdent("Int"), Some(Return(Literal(Constant.Int(4)))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f3", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Ident("i")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f3", Nil, List(List(ValDef("i", TypeIdent("Int"), None))), TypeIdent("Int"), Some(Ident("i")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f4", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None)), List(ValDef("j", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Ident("i"), "+"), List(Term.Ident("j")))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f4", Nil, List(List(ValDef("i", TypeIdent("Int"), None)), List(ValDef("j", TypeIdent("Int"), None))), TypeIdent("Int"), Some(Apply(Select(Ident("i"), "+"), List(Ident("j")))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f5", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Ident("i"))), DefDef("f5$default$1", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(9))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f5", Nil, List(List(ValDef("i", TypeIdent("Int"), None))), TypeIdent("Int"), Some(Ident("i"))), DefDef("f5$default$1", Nil, Nil, Inferred(), Some(Literal(Constant.Int(9))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f6", List(TypeDef("T", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred()))), List(List(ValDef("x", TypeTree.TypeIdent("T"), None))), TypeTree.TypeIdent("T"), Some(Term.Ident("x")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f6", List(TypeDef("T", TypeBoundsTree(Inferred(), Inferred()))), List(List(ValDef("x", TypeIdent("T"), None))), TypeIdent("T"), Some(Ident("x")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f7", List(TypeDef("T", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred()))), List(List(ValDef("x", TypeTree.TypeIdent("T"), None))), TypeTree.Singleton(Term.Ident("x")), Some(Term.Ident("x")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f7", List(TypeDef("T", TypeBoundsTree(Inferred(), Inferred()))), List(List(ValDef("x", TypeIdent("T"), None))), Singleton(Ident("x")), Some(Ident("x")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f8", Nil, List(List(ValDef("i", TypeTree.Annotated(TypeTree.Applied(TypeTree.Inferred(), List(TypeTree.TypeIdent("Int"))), Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), None))), TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(9))))), Term.Apply(Term.Ident("f8"), List(Term.Typed(Term.Repeated(List(Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2)), Term.Literal(Constant.Int(3))), TypeTree.Inferred()), TypeTree.Inferred())))))
+Inlined(None, Nil, Block(List(DefDef("f8", Nil, List(List(ValDef("i", Annotated(Applied(Inferred(), List(TypeIdent("Int"))), Apply(Select(New(Inferred()), "<init>"), Nil)), None))), TypeIdent("Int"), Some(Literal(Constant.Int(9))))), Apply(Ident("f8"), List(Typed(Repeated(List(Literal(Constant.Int(1)), Literal(Constant.Int(2)), Literal(Constant.Int(3))), Inferred()), Inferred())))))
 Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("f9", Nil, List(List(ValDef("i", TypeTree.ByName(TypeTree.TypeIdent("Int")), None))), TypeTree.TypeIdent("Int"), Some(Term.Ident("i")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(DefDef("f9", Nil, List(List(ValDef("i", ByName(TypeIdent("Int")), None))), TypeIdent("Int"), Some(Ident("i")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
diff --git a/tests/run/tasty-extractors-2.check b/tests/run/tasty-extractors-2.check
index f613539862ee..84563bdee5d0 100644
--- a/tests/run/tasty-extractors-2.check
+++ b/tests/run/tasty-extractors-2.check
@@ -1,105 +1,105 @@
-Term.Inlined(None, Nil, Term.Block(List(ValDef("x", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1))))), Term.Assign(Term.Ident("x"), Term.Literal(Constant.Int(2)))))
+Inlined(None, Nil, Block(List(ValDef("x", Inferred(), Some(Literal(Constant.Int(1))))), Assign(Ident("x"), Literal(Constant.Int(2)))))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None)))
+Inlined(None, Nil, Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeIdent("Int"), None))), Inferred(), Some(Ident("x")))), Lambda(Ident("$anonfun"), None)))
 Type.AppliedType(Type.SymRef(IsClassDefSymbol(<scala.Function1>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))), List(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix())))), Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))))
 
-Term.Inlined(None, Nil, Term.Ident("???"))
+Inlined(None, Nil, Ident("???"))
 Type.SymRef(IsDefDefSymbol(<scala.Predef$.???>), Type.SymRef(IsValDefSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Literal(Constant.Int(1)))
+Inlined(None, Nil, Literal(Constant.Int(1)))
 Type.ConstantType(Constant.Int(1))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.TypeIdent("Int")))
+Inlined(None, Nil, Typed(Literal(Constant.Int(1)), TypeIdent("Int")))
 Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Ident("Nil"), TypeTree.Applied(TypeTree.TypeIdent("List"), List(TypeTree.TypeIdent("Int")))))
+Inlined(None, Nil, Typed(Ident("Nil"), Applied(TypeIdent("List"), List(TypeIdent("Int")))))
 Type.AppliedType(Type.SymRef(IsClassDefSymbol(<scala.collection.immutable.List>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Baz")), "<init>"), Nil), TypeTree.Applied(TypeTree.TypeIdent("&"), List(TypeTree.TypeIdent("Foo"), TypeTree.TypeIdent("Bar")))))
+Inlined(None, Nil, Typed(Apply(Select(New(TypeIdent("Baz")), "<init>"), Nil), Applied(TypeIdent("&"), List(TypeIdent("Foo"), TypeIdent("Bar")))))
 Type.AndType(Type.SymRef(IsClassDefSymbol(<Foo>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<empty>>), NoPrefix()))), Type.SymRef(IsClassDefSymbol(<Bar>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<empty>>), NoPrefix()))))
 
-Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.Applied(TypeTree.TypeIdent("|"), List(TypeTree.TypeIdent("Int"), TypeTree.TypeIdent("String")))))
+Inlined(None, Nil, Typed(Literal(Constant.Int(1)), Applied(TypeIdent("|"), List(TypeIdent("Int"), TypeIdent("String")))))
 Type.OrType(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix())))), Type.SymRef(IsTypeDefSymbol(<scala.Predef$.String>), Type.SymRef(IsValDefSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, Nil)), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, Nil)), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ValDef("Foo", TypeTree.TypeIdent("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo$")), "<init>"), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil), TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), Nil)), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ValDef("Foo", TypeIdent("Foo$"), Some(Apply(Select(New(TypeIdent("Foo$")), "<init>"), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil), TypeSelect(Select(Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", Singleton(Ident("Foo")), None)), Nil)), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred()))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(TypeDef("Foo", TypeBoundsTree(Inferred(), Inferred()))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeTree.TypeIdent("Int"))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(TypeDef("Foo", TypeIdent("Int"))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.TypeIdent("Null"), TypeTree.TypeIdent("Object")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(TypeDef("Foo", TypeBoundsTree(TypeIdent("Null"), TypeIdent("Object")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(0)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Inferred(), None))), TypeTree.Inferred(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), Some(Literal(Constant.Int(0)))), DefDef("a_=", Nil, List(List(ValDef("x$1", Inferred(), None))), Inferred(), Some(Literal(Constant.Unit())))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(DefDef("a", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(DefDef("a", Nil, Nil, Inferred(), Some(Literal(Constant.Int(0))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(DefDef("a", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(DefDef("a", Nil, Nil, Inferred(), Some(Literal(Constant.Int(0))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(DefDef("a", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(DefDef("a", Nil, Nil, Inferred(), Some(Literal(Constant.Int(0))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil), TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Product"), TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Serializable")), Nil, None, List(DefDef("productElementName", Nil, List(List(ValDef("x$1", TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Int"), None))), TypeTree.TypeSelect(Term.Select(Term.Ident("java"), "lang"), "String"), Some(Term.Match(Term.Ident("x$1"), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Apply(Term.Ident("throw"), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeSelect(Term.Select(Term.Ident("java"), "lang"), "IndexOutOfBoundsException")), "<init>"), List(Term.Apply(Term.Select(Term.Select(Term.Select(Term.Ident("java"), "lang"), "String"), "valueOf"), List(Term.Ident("x$1")))))))))))), DefDef("copy", Nil, List(Nil), TypeTree.Inferred(), Some(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil))))), ValDef("Foo", TypeTree.TypeIdent("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo$")), "<init>"), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil), TypeTree.Applied(TypeTree.Inferred(), List(TypeTree.Inferred())), TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), List(DefDef("apply", Nil, List(Nil), TypeTree.Inferred(), Some(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil))), DefDef("unapply", Nil, List(List(ValDef("x$1", TypeTree.Inferred(), None))), TypeTree.Inferred(), Some(Term.Literal(Constant.Boolean(true))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil), TypeSelect(Select(Ident("_root_"), "scala"), "Product"), TypeSelect(Select(Ident("_root_"), "scala"), "Serializable")), Nil, None, List(DefDef("productElementName", Nil, List(List(ValDef("x$1", TypeSelect(Select(Ident("_root_"), "scala"), "Int"), None))), TypeSelect(Select(Ident("java"), "lang"), "String"), Some(Match(Ident("x$1"), List(CaseDef(Pattern.Value(Ident("_")), None, Apply(Ident("throw"), List(Apply(Select(New(TypeSelect(Select(Ident("java"), "lang"), "IndexOutOfBoundsException")), "<init>"), List(Apply(Select(Select(Select(Ident("java"), "lang"), "String"), "valueOf"), List(Ident("x$1")))))))))))), DefDef("copy", Nil, List(Nil), Inferred(), Some(Apply(Select(New(Inferred()), "<init>"), Nil))))), ValDef("Foo", TypeIdent("Foo$"), Some(Apply(Select(New(TypeIdent("Foo$")), "<init>"), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil), Applied(Inferred(), List(Inferred())), TypeSelect(Select(Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", Singleton(Ident("Foo")), None)), List(DefDef("apply", Nil, List(Nil), Inferred(), Some(Apply(Select(New(Inferred()), "<init>"), Nil))), DefDef("unapply", Nil, List(List(ValDef("x$1", Inferred(), None))), Inferred(), Some(Literal(Constant.Boolean(true))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo1", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), None)))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo1", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None)))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("b", TypeTree.Inferred(), None)))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(List(ValDef("b", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("b", Inferred(), None)))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo3", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), None))), ValDef("Foo3", TypeTree.TypeIdent("Foo3$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo3$")), "<init>"), Nil))), ClassDef("Foo3$", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil), TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo3")), None)), List(DefDef("$lessinit$greater$default$1", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(5))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo3", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None))), ValDef("Foo3", TypeIdent("Foo3$"), Some(Apply(Select(New(TypeIdent("Foo3$")), "<init>"), Nil))), ClassDef("Foo3$", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil), TypeSelect(Select(Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", Singleton(Ident("Foo3")), None)), List(DefDef("$lessinit$greater$default$1", Nil, Nil, Inferred(), Some(Literal(Constant.Int(5))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo4", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None)), List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), None), ValDef("b", TypeTree.Inferred(), None)))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo4", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None)), List(ValDef("b", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), ValDef("b", Inferred(), None)))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo5", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None)), List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), None), ValDef("b", TypeTree.Inferred(), None))), ValDef("Foo5", TypeTree.TypeIdent("Foo5$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo5$")), "<init>"), Nil))), ClassDef("Foo5$", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil), TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo5")), None)), List(DefDef("$lessinit$greater$default$2", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), Some(Term.Ident("a")))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo5", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None)), List(ValDef("b", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), ValDef("b", Inferred(), None))), ValDef("Foo5", TypeIdent("Foo5$"), Some(Apply(Select(New(TypeIdent("Foo5$")), "<init>"), Nil))), ClassDef("Foo5$", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil), TypeSelect(Select(Ident("_root_"), "scala"), "Serializable")), Nil, Some(ValDef("_", Singleton(Ident("Foo5")), None)), List(DefDef("$lessinit$greater$default$2", Nil, List(List(ValDef("a", TypeIdent("Int"), None))), Inferred(), Some(Ident("a")))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo6", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None)), List(ValDef("b", TypeTree.Singleton(Term.Ident("a")), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), None), ValDef("b", TypeTree.Inferred(), None)))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo6", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None)), List(ValDef("b", Singleton(Ident("a")), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), ValDef("b", Inferred(), None)))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo7", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), None), DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), Some(Term.Block(List(Term.Apply(Term.Select(Term.This(Some(Id("Foo7"))), "<init>"), List(Term.Literal(Constant.Int(6))))), Term.Literal(Constant.Unit()))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo7", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), DefDef("<init>", Nil, List(Nil), Inferred(), Some(Block(List(Apply(Select(This(Some(Id("Foo7"))), "<init>"), List(Literal(Constant.Int(6))))), Literal(Constant.Unit()))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo8", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo8", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(Apply(Ident("println"), List(Literal(Constant.Int(0))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo10", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(9))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo10", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), Some(Literal(Constant.Int(9))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo11", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(10)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Inferred(), None))), TypeTree.Inferred(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo11", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), Some(Literal(Constant.Int(10)))), DefDef("a_=", Nil, List(List(ValDef("x$1", Inferred(), None))), Inferred(), Some(Literal(Constant.Unit())))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo12", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(11))))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo12", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), Some(Literal(Constant.Int(11))))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo")), "<init>"), Nil)), Nil, None, Nil)), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(TypeIdent("Foo")), "<init>"), Nil)), Nil, None, Nil)), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(TypeTree.Inferred()), Nil, None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil), TypeTree.TypeIdent("Foo2")), Nil, None, Nil)), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Inferred()), Nil, None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil), TypeIdent("Foo2")), Nil, None, Nil)), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("i", TypeTree.Inferred(), None))), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo")), "<init>"), List(Term.Literal(Constant.Int(1))))), Nil, None, Nil)), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(List(ValDef("i", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("i", Inferred(), None))), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(TypeIdent("Foo")), "<init>"), List(Literal(Constant.Int(1))))), Nil, None, Nil)), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("X", TypeTree.TypeIdent("Int")))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Foo"), None))), TypeTree.TypeSelect(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("X", TypeIdent("Int")))), DefDef("f", Nil, List(List(ValDef("a", TypeIdent("Foo"), None))), TypeSelect(Ident("a"), "X"), Some(Ident("???")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("X", TypeBoundsTree(TypeTree.Inferred(), TypeTree.Inferred())))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.Refined(TypeTree.TypeIdent("Foo"), List(TypeDef("X", TypeTree.TypeIdent("Int")))), None))), TypeTree.TypeSelect(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("X", TypeBoundsTree(Inferred(), Inferred())))), DefDef("f", Nil, List(List(ValDef("a", Refined(TypeIdent("Foo"), List(TypeDef("X", TypeIdent("Int")))), None))), TypeSelect(Ident("a"), "X"), Some(Ident("???")))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
-Term.Inlined(None, Nil, Term.Block(List(ValDef("lambda", TypeTree.Applied(TypeTree.Inferred(), List(TypeTree.TypeIdent("Int"), TypeTree.TypeIdent("Int"))), Some(Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.Inferred(), None))), TypeTree.Inferred(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None))))), Term.Literal(Constant.Unit())))
+Inlined(None, Nil, Block(List(ValDef("lambda", Applied(Inferred(), List(TypeIdent("Int"), TypeIdent("Int"))), Some(Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", Inferred(), None))), Inferred(), Some(Ident("x")))), Lambda(Ident("$anonfun"), None))))), Literal(Constant.Unit())))
 Type.SymRef(IsClassDefSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))
 
diff --git a/tests/run/tasty-extractors-types.check b/tests/run/tasty-extractors-types.check
index b198d9dae9c6..b66091f1680b 100644
--- a/tests/run/tasty-extractors-types.check
+++ b/tests/run/tasty-extractors-types.check
@@ -1,12 +1,12 @@
-TypeTree.Inferred()
+Inferred()
 Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))
 
-TypeTree.Inferred()
+Inferred()
 Type.AppliedType(Type.SymRef(IsClassDefSymbol(<scala.collection.immutable.List>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsTypeDefSymbol(<scala.Predef$.String>), Type.SymRef(IsValDefSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix()))))))
 
-TypeTree.Inferred()
+Inferred()
 Type.AppliedType(Type.SymRef(IsClassDefSymbol(<scala.collection.immutable.Map>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsTypeDefSymbol(<scala.Predef$.String>), Type.SymRef(IsValDefSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))), Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))))
 
-TypeTree.Inferred()
+Inferred()
 Type.AppliedType(Type.SymRef(IsClassDefSymbol(<scala.collection.immutable.Map>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsTypeDefSymbol(<scala.Predef$.String>), Type.SymRef(IsValDefSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<scala>), NoPrefix())))), Type.SymRef(IsTypeDefSymbol(<Test$._$I>), NoPrefix())))
 
diff --git a/tests/run/tasty-interpolation-1/Macro.scala b/tests/run/tasty-interpolation-1/Macro.scala
index 106ddac78a52..8da5d0e45017 100644
--- a/tests/run/tasty-interpolation-1/Macro.scala
+++ b/tests/run/tasty-interpolation-1/Macro.scala
@@ -56,9 +56,9 @@ abstract class MacroStringInterpolator[T] {
   protected def getStaticStringContext(strCtxExpr: Expr[StringContext])(implicit reflect: Reflection): StringContext = {
     import reflect._
     strCtxExpr.unseal.underlyingArgument match {
-      case Term.Select(Term.Typed(Term.Apply(_, List(Term.Apply(_, List(Term.Typed(Term.Repeated(strCtxArgTrees, _), TypeTree.Inferred()))))), _), _) =>
+      case Select(Typed(Apply(_, List(Apply(_, List(Typed(Repeated(strCtxArgTrees, _), Inferred()))))), _), _) =>
         val strCtxArgs = strCtxArgTrees.map {
-          case Term.Literal(Constant.String(str)) => str
+          case Literal(Constant.String(str)) => str
           case tree => throw new NotStaticlyKnownError("Expected statically known StringContext", tree.seal[Any])
         }
         StringContext(strCtxArgs: _*)
@@ -70,7 +70,7 @@ abstract class MacroStringInterpolator[T] {
   protected def getArgsList(argsExpr: Expr[Seq[Any]])(implicit reflect: Reflection): List[Expr[Any]] = {
     import reflect._
     argsExpr.unseal.underlyingArgument match {
-      case Term.Typed(Term.Repeated(args, _), _) => args.map(_.seal[Any])
+      case Typed(Repeated(args, _), _) => args.map(_.seal[Any])
       case tree => throw new NotStaticlyKnownError("Expected statically known argument list", tree.seal[Any])
     }
   }
diff --git a/tests/run/tasty-macro-assert/quoted_1.scala b/tests/run/tasty-macro-assert/quoted_1.scala
index 0e97464c5d12..1a749551f1a5 100644
--- a/tests/run/tasty-macro-assert/quoted_1.scala
+++ b/tests/run/tasty-macro-assert/quoted_1.scala
@@ -26,14 +26,14 @@ object Asserts {
 
     object OpsTree {
       def unapply(arg: Term): Option[Term] = arg match {
-        case Term.Apply(Term.TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
+        case Apply(TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
           Some(left)
         case _ => None
       }
     }
 
     tree match {
-      case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
+      case Inlined(_, Nil, Apply(Select(OpsTree(left), op), right :: Nil)) =>
         op match {
           case "===" => '{assertEquals(${left.seal[Any]}, ${right.seal[Any]})}
           case "!==" => '{assertNotEquals(${left.seal[Any]}, ${right.seal[Any]})}
diff --git a/tests/run/tasty-macro-const/quoted_1.scala b/tests/run/tasty-macro-const/quoted_1.scala
index 20f419545bf0..acb9e1cdf502 100644
--- a/tests/run/tasty-macro-const/quoted_1.scala
+++ b/tests/run/tasty-macro-const/quoted_1.scala
@@ -9,7 +9,7 @@ object Macros {
     import reflection._
     val xTree: Term = x.unseal
     xTree match {
-      case Term.Inlined(_, _, Term.Literal(Constant.Int(n))) =>
+      case Inlined(_, _, Literal(Constant.Int(n))) =>
         if (n <= 0)
           throw new QuoteError("Parameter must be natural number")
         xTree.seal[Int]
diff --git a/tests/run/tasty-seal-method/quoted_1.scala b/tests/run/tasty-seal-method/quoted_1.scala
index 41cff0a6ccee..f4667f97a853 100644
--- a/tests/run/tasty-seal-method/quoted_1.scala
+++ b/tests/run/tasty-seal-method/quoted_1.scala
@@ -12,7 +12,7 @@ object Asserts {
     import reflect._
     // For simplicity assumes that all parameters are Int and parameter lists have no more than 3 elements
     x.unseal.underlyingArgument match {
-      case Term.Apply(fn, args) =>
+      case Apply(fn, args) =>
         fn.tpe.widen match {
           case Type.IsMethodType(_) =>
             args.size match {
@@ -34,7 +34,7 @@ object Asserts {
     import reflect._
     // For simplicity assumes that all parameters are Int and parameter lists have no more than 3 elements
     def rec(term: Term): Term = term match {
-      case Term.Apply(fn, args) =>
+      case Apply(fn, args) =>
         val pre = rec(fn)
         args.size match {
           case 0 => pre.seal[() => Any].apply().unseal
diff --git a/tests/run/xml-interpolation-1/XmlQuote_1.scala b/tests/run/xml-interpolation-1/XmlQuote_1.scala
index 6986ba42ef8b..0c5169060b27 100644
--- a/tests/run/xml-interpolation-1/XmlQuote_1.scala
+++ b/tests/run/xml-interpolation-1/XmlQuote_1.scala
@@ -14,7 +14,6 @@ object XmlQuote {
   def impl(receiver: Expr[SCOps], args: Expr[Seq[Any]])
           (implicit reflect: Reflection): Expr[Xml] = {
     import reflect._
-    import Term._
 
     def abort(msg: String): Nothing =
       throw new QuoteError(msg)
diff --git a/tests/run/xml-interpolation-2/XmlQuote_1.scala b/tests/run/xml-interpolation-2/XmlQuote_1.scala
index 2d5792a4831f..a7fba5acce75 100644
--- a/tests/run/xml-interpolation-2/XmlQuote_1.scala
+++ b/tests/run/xml-interpolation-2/XmlQuote_1.scala
@@ -17,7 +17,6 @@ object XmlQuote {
   def impl(receiver: Expr[SCOps], args: Expr[Seq[Any]])
           (implicit reflect: Reflection): Expr[Xml] = {
     import reflect._
-    import Term._
 
     // for debugging purpose
     def pp(tree: Tree): Unit = {