diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TastyImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TastyImpl.scala
index 9124bd99c9c2..4b6409a80310 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TastyImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TastyImpl.scala
@@ -448,9 +448,9 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
     }
 
     object Inlined extends InlinedExtractor {
-      def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[Statement], Term)] = x match {
+      def unapply(x: Term)(implicit ctx: Context): Option[(Option[Term], List[Statement], Term)] = x match {
         case x: tpd.Inlined @unchecked =>
-          Some((x.call, x.bindings, x.expansion))
+          Some((optional(x.call), x.bindings, x.expansion))
         case _ => None
       }
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 7d30e3260dd3..a5b78a2c0ebf 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -167,7 +167,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         if (c.owner eq c.outer.owner) markAsMacro(c.outer)
         else if (c.owner.isTransparentMethod) {
           c.owner.setFlag(Macro)
-          c.owner.resetFlag(Erased) // FIXME: Macros should be Erased, but that causes problems right now
         }
         else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
 
@@ -245,12 +244,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           //     be duplicated
           //  2. To enable correct pickling (calls can share symbols with the inlined code, which
           //     would trigger an assertion when pickling).
-          // In the case of macros we keep the call to be able to reconstruct the parameters that
-          // are passed to the macro. This same simplification is applied in ReifiedQuotes when the
-          // macro splices are evaluated.
-          val callTrace =
-            if (call.symbol.is(Macro)) call
-            else Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
+          val callTrace = Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
           cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(inlineContext(call)))
         case tree: Template =>
           withNoCheckNews(tree.parents.flatMap(newPart)) {
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
index 6993ebf50abb..72e6c97c10dc 100644
--- a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
@@ -7,13 +7,10 @@ import Flags._
 import ast.Trees._
 import ast.{TreeTypeMap, untpd}
 import util.Positions._
-import StdNames._
 import tasty.TreePickler.Hole
-import MegaPhase.MiniPhase
 import SymUtils._
 import NameKinds._
 import dotty.tools.dotc.ast.tpd.Tree
-import dotty.tools.dotc.core.DenotTransformers.InfoTransformer
 import typer.Implicits.SearchFailureType
 
 import scala.collection.mutable
@@ -60,33 +57,9 @@ import dotty.tools.dotc.core.quoted._
  *
  *
  *  For transparent macro definitions we assume that we have a single ~ directly as the RHS.
- *  We will transform the definition from
- *    ```
- *    transparent def foo[T1, ...] (transparent x1: X, ..., y1: Y, ....): Z = ~{ ... T1 ... x ... '(y) ... }
- *    ```
- *  to
- *    ```
- *    transparent def foo[T1, ...] (transparent x1: X, ..., y1: Y, ....): Seq[Any] => Object = { (args: Seq[Any]) => {
- *      val T1$1 = args(0).asInstanceOf[Type[T1]]
- *      ...
- *      val x1$1 = args(0).asInstanceOf[X]
- *      ...
- *      val y1$1 = args(1).asInstanceOf[Expr[Y]]
- *      ...
- *      { ... x1$1 .... '{ ... T1$1.unary_~ ... x1$1.toExpr.unary_~ ... y1$1.unary_~ ... } ... }
- *    }
- *    ```
- *  Where `transparent` parameters with type Boolean, Byte, Short, Int, Long, Float, Double, Char and String are
- *  passed as their actual runtime value. See `isStage0Value`. Other `transparent` arguments such as functions are handled
- *  like `y1: Y`.
- *
- *  Note: the parameters of `foo` are kept for simple overloading resolution but they are not used in the body of `foo`.
- *
- *  At inline site we will call reflectively the static method `foo` with dummy parameters, which will return a
- *  precompiled version of the function that will evaluate the `Expr[Z]` that `foo` produces. The lambda is then called
- *  at the inline site with the lifted arguments of the inlined call.
+ *  The Splicer is used to check that the RHS will be interpretable (with the `Splicer`) once inlined.
  */
-class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
+class ReifyQuotes extends MacroTransformWithImplicits {
   import ast.tpd._
 
   /** Classloader used for loading macros */
@@ -255,7 +228,7 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
         !sym.is(Param) || levelOK(sym.owner)
     }
 
-    /** Issue a "splice outside quote" error unless we ar in the body of a transparent method */
+    /** Issue a "splice outside quote" error unless we are in the body of a transparent method */
     def spliceOutsideQuotes(pos: Position)(implicit ctx: Context): Unit =
       ctx.error(i"splice outside quotes", pos)
 
@@ -267,7 +240,7 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
     def tryHeal(tp: Type, pos: Position)(implicit ctx: Context): Option[String] = tp match {
       case tp: TypeRef =>
         if (level == 0) {
-          assert(ctx.owner.ownersIterator.exists(_.is(Macro)))
+          assert(ctx.owner.ownersIterator.exists(_.is(Transparent)))
           None
         } else {
           val reqType = defn.QuotedTypeType.appliedTo(tp)
@@ -298,7 +271,7 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
         else i"${sym.name}.this"
       if (!isThis && sym.maybeOwner.isType && !sym.is(Param))
         check(sym.owner, sym.owner.thisType, pos)
-      else if (level == 1 && sym.isType && sym.is(Param) && sym.owner.is(Macro) && !outer.isRoot)
+      else if (level == 1 && sym.isType && sym.is(Param) && sym.owner.is(Transparent) && !outer.isRoot)
         importedTags(sym.typeRef) = capturers(sym)(ref(sym))
       else if (sym.exists && !sym.isStaticOwner && !levelOK(sym))
         for (errMsg <- tryHeal(tp, pos))
@@ -510,18 +483,7 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
       val captured = mutable.LinkedHashMap.empty[Symbol, Tree]
       val captured2 = capturer(captured)
 
-      def registerCapturer(sym: Symbol): Unit = capturers.put(sym, captured2)
-      def forceCapture(sym: Symbol): Unit = captured2(ref(sym))
-
-      outer.enteredSyms.foreach(registerCapturer)
-
-      if (ctx.owner.owner.is(Macro)) {
-        registerCapturer(defn.TastyTopLevelSplice_tastyContext)
-        // Force a macro to have the context in first position
-        forceCapture(defn.TastyTopLevelSplice_tastyContext)
-        // Force all parameters of the macro to be created in the definition order
-        outer.enteredSyms.reverse.foreach(forceCapture)
-      }
+      outer.enteredSyms.foreach(sym => capturers.put(sym, captured2))
 
       val tree2 = transform(tree)
       capturers --= outer.enteredSyms
@@ -582,16 +544,12 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
             val last = enteredSyms
             stats.foreach(markDef)
             mapOverTree(last)
-          case Inlined(call, bindings, InlineSplice(expansion @ Select(body, name))) if !call.isEmpty =>
-            assert(call.symbol.is(Macro))
+          case Inlined(call, bindings, InlineSplice(spliced)) if !call.isEmpty =>
             val tree2 =
               if (level == 0) {
-                // Simplification of the call done in PostTyper for non-macros can also be performed now
-                // see PostTyper `case Inlined(...) =>` for description of the simplification
-                val call2 = Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
-                val spliced = Splicer.splice(body, call, bindings, tree.pos, macroClassLoader).withPos(tree.pos)
+                val evaluatedSplice = Splicer.splice(spliced, tree.pos, macroClassLoader).withPos(tree.pos)
                 if (ctx.reporter.hasErrors) EmptyTree
-                else transform(cpy.Inlined(tree)(call2, bindings, spliced))
+                else transform(cpy.Inlined(tree)(call, bindings, evaluatedSplice))
               }
               else super.transform(tree)
 
@@ -607,22 +565,16 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
                   ctx.error("Transparent macro method must be a static method.", tree.pos)
                 markDef(tree)
                 val reifier = nested(isQuote = true)
-                reifier.transform(tree) // Ignore output, we only need the its embedding
-                assert(reifier.embedded.size == 1)
-                val lambda = reifier.embedded.head
-                // replace macro code by lambda used to evaluate the macro expansion
-                cpy.DefDef(tree)(tpt = TypeTree(macroReturnType), rhs = lambda)
+                reifier.transform(tree) // Ignore output, only check PCP
+                cpy.DefDef(tree)(rhs = defaultValue(tree.rhs.tpe))
               case _ =>
                 ctx.error(
                   """Malformed transparent macro.
                     |
                     |Expected the ~ to be at the top of the RHS:
-                    |  transparent def foo(...): Int = ~impl(...)
-                    |or
-                    |  transparent def foo(...): Int = ~{
-                    |    val x = 1
-                    |    impl(... x ...)
-                    |  }
+                    |  transparent def foo(x: X, ..., y: Y): Int = ~impl(x, ... '(y))
+                    |
+                    |The contents of the splice must call a static method. Arguments must be quoted or inlined.
                   """.stripMargin, tree.rhs.pos)
                 EmptyTree
             }
@@ -651,7 +603,7 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
     }
 
     private def isStage0Value(sym: Symbol)(implicit ctx: Context): Boolean =
-      (sym.is(Transparent) && sym.owner.is(Macro) && !defn.isFunctionType(sym.info)) ||
+      (sym.is(Transparent) && sym.owner.is(Transparent) && !defn.isFunctionType(sym.info)) ||
       sym == defn.TastyTopLevelSplice_tastyContext // intrinsic value at stage 0
 
     private def liftList(list: List[Tree], tpe: Type)(implicit ctx: Context): Tree = {
@@ -664,38 +616,14 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
      *  consists of a (possibly multiple & nested) block or a sole expression.
      */
     object InlineSplice {
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = {
-        tree match {
-          case expansion: Select if expansion.symbol.isSplice => Some(expansion)
-          case Block(List(stat), Literal(Constant(()))) => unapply(stat)
-          case Block(Nil, expr) => unapply(expr)
-          case _ => None
-        }
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = tree match {
+        case Select(qual, _) if tree.symbol.isSplice && Splicer.canBeSpliced(qual) => Some(qual)
+        case Block(List(stat), Literal(Constant(()))) => unapply(stat)
+        case Block(Nil, expr) => unapply(expr)
+        case _ => None
       }
     }
   }
-
-  def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = {
-    /** Transforms the return type of
-     *    transparent def foo(...): X = ~(...)
-     *  to
-     *    transparent def foo(...): Seq[Any] => Expr[Any] = (args: Seq[Any]) => ...
-     */
-    def transform(tp: Type): Type = tp match {
-      case tp: MethodType => MethodType(tp.paramNames, tp.paramInfos, transform(tp.resType))
-      case tp: PolyType => PolyType(tp.paramNames, tp.paramInfos, transform(tp.resType))
-      case tp: ExprType => ExprType(transform(tp.resType))
-      case _ => macroReturnType
-    }
-    transform(tp)
-  }
-
-  override protected def mayChange(sym: Symbol)(implicit ctx: Context): Boolean =
-    ctx.compilationUnit.containsQuotesOrSplices && sym.isTerm && sym.is(Macro)
-
-  /** Returns the type of the compiled macro as a lambda: Seq[Any] => Object */
-  private def macroReturnType(implicit ctx: Context): Type =
-    defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), defn.ObjectType)
 }
 
 object ReifyQuotes {
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 7c4b942429f7..cd2cc08ee4c3 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -2,12 +2,13 @@ package dotty.tools.dotc
 package transform
 
 import java.io.{PrintWriter, StringWriter}
-import java.lang.reflect.Method
+import java.lang.reflect.{InvocationTargetException, Method}
 
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags.Package
+import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.NameKinds.FlatName
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.StdNames.str.MODULE_INSTANCE_FIELD
@@ -15,6 +16,7 @@ import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.TypeErasure
+import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.tastyreflect.TastyImpl
 
 import scala.util.control.NonFatal
@@ -32,89 +34,52 @@ object Splicer {
    *
    *  See: `ReifyQuotes`
    */
-  def splice(tree: Tree, call: Tree, bindings: List[Tree], pos: Position, classLoader: ClassLoader)(implicit ctx: Context): Tree = tree match {
+  def splice(tree: Tree, pos: Position, classLoader: ClassLoader)(implicit ctx: Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
     case _ =>
-      val liftedArgs = getLiftedArgs(call, bindings)
       val interpreter = new Interpreter(pos, classLoader)
-      val interpreted = interpreter.interpretCallToSymbol[Seq[Any] => Object](call.symbol)
-      val tctx = new TastyImpl(ctx)
-      evaluateMacro(pos) {
+      try {
         // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
-        val evaluated = interpreted.map(lambda => lambda(tctx :: liftedArgs).asInstanceOf[scala.quoted.Expr[Nothing]])
-        evaluated.fold(tree)(PickledQuotes.quotedExprToTree)
+        val interpreted = interpreter.interpret[scala.quoted.Expr[Any]](tree)
+        interpreted.fold(tree)(x => PickledQuotes.quotedExprToTree(x))
+      }
+      catch {
+        case ex: scala.quoted.QuoteError =>
+          ctx.error(ex.getMessage, pos)
+          EmptyTree
+        case NonFatal(ex) =>
+          val msg =
+            s"""Failed to evaluate macro.
+               |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
+               |    ${ex.getStackTrace.takeWhile(_.getClassName != "dotty.tools.dotc.transform.Splicer$").init.mkString("\n    ")}
+             """.stripMargin
+          ctx.error(msg, pos)
+          EmptyTree
       }
   }
 
-  /** Given the inline code and bindings, compute the lifted arguments that will be used to execute the macro
-   *  - Type parameters are lifted to quoted.Types.TreeType
-   *  - Inline parameters are listed as their value
-   *  - Other parameters are lifted to quoted.Types.TreeExpr (may reference a binding)
-   */
-  private def getLiftedArgs(call: Tree, bindings: List[Tree])(implicit ctx: Context): List[Any] = {
-    val bindMap = bindings.collect {
-      case vdef: ValDef => (vdef.rhs, ref(vdef.symbol).withPos(vdef.rhs.pos))
-    }.toMap
-    def allArgs(call: Tree, acc: List[List[Tree]]): List[List[Tree]] = call match {
-      case call: Apply => allArgs(call.fun, call.args :: acc)
-      case call: TypeApply => allArgs(call.fun, call.args :: acc)
-      case _ => acc
-    }
-    def liftArgs(tpe: Type, args: List[List[Tree]]): List[Any] = tpe match {
-      case tp: MethodType =>
-        val args1 = args.head.zip(tp.paramInfos).map {
-          case (arg: Literal, tp) if tp.hasAnnotation(defn.TransparentParamAnnot) => arg.const.value
-          case (arg, tp) =>
-            assert(!tp.hasAnnotation(defn.TransparentParamAnnot))
-            // Replace argument by its binding
-            val arg1 = bindMap.getOrElse(arg, arg)
-            new scala.quoted.Exprs.TastyTreeExpr(arg1)
-        }
-        args1 ::: liftArgs(tp.resType, args.tail)
-      case tp: PolyType =>
-        val args1 = args.head.map(tp => new scala.quoted.Types.TreeType(tp))
-        args1 ::: liftArgs(tp.resType, args.tail)
-      case _ => Nil
-    }
-
-    liftArgs(call.symbol.info, allArgs(call, Nil))
+  /** Check that the Tree can be spliced. `~'(xyz)` becomes `xyz`
+    *  and for `~xyz` the tree of `xyz` is interpreted for which the
+    *  resulting expression is returned as a `Tree`
+    *
+    *  See: `ReifyQuotes`
+    */
+  def canBeSpliced(tree: Tree)(implicit ctx: Context): Boolean = tree match {
+    case Quoted(_) => true
+    case _ => (new CanBeInterpreted).apply(tree)
   }
 
-  /* Evaluate the code in the macro and handle exceptions durring evaluation */
-  private def evaluateMacro(pos: Position)(code: => Tree)(implicit ctx: Context): Tree = {
-    try code
-    catch {
-      case ex: scala.quoted.QuoteError =>
-        ctx.error(ex.getMessage, pos)
-        EmptyTree
-      case NonFatal(ex) =>
-        val msg =
-          s"""Failed to evaluate inlined quote.
-             |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
-             |    ${ex.getStackTrace.takeWhile(_.getClassName != "dotty.tools.dotc.transform.Splicer$").init.mkString("\n    ")}
-           """.stripMargin
-        ctx.error(msg, pos)
-        EmptyTree
-    }
-  }
+  /** Tree interpreter that evaluates the tree */
+  private class Interpreter(pos: Position, classLoader: ClassLoader)(implicit ctx: Context) extends AbstractInterpreter {
 
-  /** Tree interpreter that can interpret calls to static methods with it's default arguments
-   *
-   *  The interpreter assumes that all calls in the trees are to code that was
-   *  previously compiled and is present in the classpath of the current context.
-   */
-  private class Interpreter(pos: Position, classLoader: ClassLoader)(implicit ctx: Context) {
+    type Result = Object
 
     /** Returns the interpreted result of interpreting the code a call to the symbol with default arguments.
      *  Return Some of the result or None if some error happen during the interpretation.
      */
-    def interpretCallToSymbol[T](sym: Symbol)(implicit ct: ClassTag[T]): Option[T] = {
+    def interpret[T](tree: Tree)(implicit ct: ClassTag[T]): Option[T] = {
       try {
-        val (clazz, instance) = loadModule(sym.owner)
-        val paramClasses = paramsSig(sym)
-        val interpretedArgs = paramClasses.map(defaultValue)
-        val method = getMethod(clazz, sym.name, paramClasses)
-        stopIfRuntimeException(method.invoke(instance, interpretedArgs: _*)) match {
+        interpretTree(tree)(Map.empty) match {
           case obj: T => Some(obj)
           case obj =>
             // TODO upgrade to a full type tag check or something similar
@@ -128,6 +93,27 @@ object Splicer {
       }
     }
 
+    protected def interpretQuote(tree: Tree)(implicit env: Env): Object =
+      new scala.quoted.Exprs.TastyTreeExpr(tree)
+
+    protected def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
+      new scala.quoted.Types.TreeType(tree)
+
+    protected def interpretLiteral(value: Any)(implicit env: Env): Object =
+      value.asInstanceOf[Object]
+
+    protected def interpretTastyContext()(implicit env: Env): Object =
+      new TastyImpl(ctx)
+
+    protected def interpretStaticMethodCall(fn: Tree, args: => List[Object])(implicit env: Env): Object = {
+      val (clazz, instance) = loadModule(fn.symbol.owner)
+      val method = getMethod(clazz, fn.symbol.name, paramsSig(fn.symbol))
+      stopIfRuntimeException(method.invoke(instance, args: _*))
+    }
+
+    protected def unexpectedTree(tree: Tree)(implicit env: Env): Object =
+      throw new StopInterpretation("Unexpected tree could not be interpreted: " + tree, tree.pos)
+
     private def loadModule(sym: Symbol): (Class[_], Object) = {
       if (sym.owner.is(Package)) {
         // is top level object
@@ -172,6 +158,15 @@ object Splicer {
           ex.printStackTrace(new PrintWriter(sw))
           sw.write("\n")
           throw new StopInterpretation(sw.toString, pos)
+        case ex: InvocationTargetException =>
+          val sw = new StringWriter()
+          sw.write("An exception occurred while executing macro expansion\n")
+          sw.write(ex.getTargetException.getMessage)
+          sw.write("\n")
+          ex.getTargetException.printStackTrace(new PrintWriter(sw))
+          sw.write("\n")
+          throw new StopInterpretation(sw.toString, pos)
+
       }
     }
 
@@ -223,22 +218,83 @@ object Splicer {
       }
     }
 
-    /** Get the default value for the given class */
-    private def defaultValue(clazz: Class[_]): Object = {
-      if (clazz == classOf[Boolean]) false.asInstanceOf[Object]
-      else if (clazz == classOf[Byte]) 0.toByte.asInstanceOf[Object]
-      else if (clazz == classOf[Char]) 0.toChar.asInstanceOf[Object]
-      else if (clazz == classOf[Short]) 0.asInstanceOf[Object]
-      else if (clazz == classOf[Int]) 0.asInstanceOf[Object]
-      else if (clazz == classOf[Long]) 0L.asInstanceOf[Object]
-      else if (clazz == classOf[Float]) 0f.asInstanceOf[Object]
-      else if (clazz == classOf[Double]) 0d.asInstanceOf[Object]
-      else null
-    }
-
     /** Exception that stops interpretation if some issue is found */
     private class StopInterpretation(val msg: String, val pos: Position) extends Exception
 
   }
 
+  /** Tree interpreter that tests if tree can be interpreted */
+  private class CanBeInterpreted(implicit ctx: Context) extends AbstractInterpreter {
+
+    type Result = Boolean
+
+    def apply(tree: Tree): Boolean = interpretTree(tree)(Map.empty)
+
+    def interpretQuote(tree: tpd.Tree)(implicit env: Env): Boolean = true
+    def interpretTypeQuote(tree: tpd.Tree)(implicit env: Env): Boolean = true
+    def interpretLiteral(value: Any)(implicit env: Env): Boolean = true
+    def interpretTastyContext()(implicit env: Env): Boolean = true
+    def interpretStaticMethodCall(fn: tpd.Tree, args: => List[Boolean])(implicit env: Env): Boolean = args.forall(identity)
+
+    def unexpectedTree(tree: tpd.Tree)(implicit env: Env): Boolean = {
+      // Assuming that top-level splices can only be in transparent methods
+      // and splices are expanded at inline site, references to transparent values
+      // will be know literal constant trees.
+      tree.symbol.is(Transparent)
+    }
+  }
+
+  /** Abstract Tree interpreter that can interpret calls to static methods with quoted or transparent arguments */
+  private abstract class AbstractInterpreter(implicit ctx: Context) {
+    type Env = Map[Name, Result]
+    type Result
+
+    protected def interpretQuote(tree: Tree)(implicit env: Env): Result
+    protected def interpretTypeQuote(tree: Tree)(implicit env: Env): Result
+    protected def interpretLiteral(value: Any)(implicit env: Env): Result
+    protected def interpretTastyContext()(implicit env: Env): Result
+    protected def interpretStaticMethodCall(fn: Tree, args: => List[Result])(implicit env: Env): Result
+    protected def unexpectedTree(tree: Tree)(implicit env: Env): Result
+
+    protected final def interpretTree(tree: Tree)(implicit env: Env): Result = tree match {
+      case Apply(TypeApply(fn, _), quoted :: Nil) if fn.symbol == defn.QuotedExpr_apply =>
+        interpretQuote(quoted)
+
+      case TypeApply(fn, quoted :: Nil) if fn.symbol == defn.QuotedType_apply =>
+        interpretTypeQuote(quoted)
+
+      case Literal(Constant(value)) =>
+        interpretLiteral(value)
+
+      case _ if tree.symbol == defn.TastyTopLevelSplice_tastyContext =>
+        interpretTastyContext()
+
+      case StaticMethodCall(fn, args) =>
+        interpretStaticMethodCall(fn, args.map(arg => interpretTree(arg)))
+
+      // Interpret `foo(j = x, i = y)` which it is expanded to
+      // `val j$1 = x; val i$1 = y; foo(i = y, j = x)`
+      case Block(stats, expr) =>
+        val newEnv = stats.foldLeft(env)((accEnv, stat) => stat match {
+          case stat: ValDef if stat.symbol.is(Synthetic) =>
+            accEnv.updated(stat.name, interpretTree(stat.rhs)(accEnv))
+          case stat => return unexpectedTree(stat)
+        })
+        interpretTree(expr)(newEnv)
+      case NamedArg(_, arg) => interpretTree(arg)
+      case Ident(name) if env.contains(name) => env(name)
+
+      case _ => unexpectedTree(tree)
+    }
+
+    object StaticMethodCall {
+      def unapply(arg: Tree): Option[(RefTree, List[Tree])] = arg match {
+        case fn: RefTree if fn.symbol.isStatic => Some((fn, Nil))
+        case Apply(StaticMethodCall(fn, args1), args2) => Some((fn, args1 ::: args2)) // TODO improve performance
+        case TypeApply(StaticMethodCall(fn, args), _) => Some((fn, args))
+        case _ => None
+      }
+    }
+  }
+
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
index 9ab6664e4857..3418f83f9d40 100644
--- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -49,7 +49,7 @@ abstract class Lifter {
       // don't instantiate here, as the type params could be further constrained, see tests/pos/pickleinf.scala
       var liftedType = expr.tpe.widen
       if (liftedFlags.is(Method)) liftedType = ExprType(liftedType)
-      val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags, liftedType, coord = positionCoord(expr.pos))
+      val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags | Synthetic, liftedType, coord = positionCoord(expr.pos))
       defs += liftedDef(lifted, expr).withPos(expr.pos)
       ref(lifted.termRef).withPos(expr.pos.focus)
     }
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 50c3efc5bad9..f3d16eb4fe0a 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -952,8 +952,6 @@ class RefChecks extends MiniPhase { thisPhase =>
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context) = {
     checkDeprecatedOvers(tree)
-    if (tree.symbol.is(Macro))
-      tree.symbol.resetFlag(Macro)
     tree
   }
 
diff --git a/docs/docs/reference/principled-meta-programming.md b/docs/docs/reference/principled-meta-programming.md
index f4b14fcc9b17..c971ecff6d22 100644
--- a/docs/docs/reference/principled-meta-programming.md
+++ b/docs/docs/reference/principled-meta-programming.md
@@ -383,7 +383,7 @@ statically known exponent:
     private def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
       if (n == 0) '(1.0)
       else if (n == 1) x
-      else if (n % 2 == 0) '{ { val y = ~x * ~x; ~powerCode(n / 2, '(y)) } }
+      else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode(n / 2, '(y)) }
       else '{ ~x * ~powerCode(n - 1, x) }
 
 The reference to `n` as an argument in `~powerCode(n, '(x))` is not
@@ -436,7 +436,8 @@ we currently impose the following restrictions on the use of splices.
  1. A top-level splice must appear in a transparent function (turning that function
     into a macro)
 
- 2. The splice must call a previously compiled method.
+ 2. The splice must call a previously compiled (previous to the call of the transparent definition)
+    static method passing quoted arguments, constant arguments or transparent arguments.
 
  3. Splices inside splices (but no intervening quotes) are not allowed.
 
diff --git a/library/src/scala/tasty/Tasty.scala b/library/src/scala/tasty/Tasty.scala
index 7b8d830f0d2c..38137c94f321 100644
--- a/library/src/scala/tasty/Tasty.scala
+++ b/library/src/scala/tasty/Tasty.scala
@@ -371,7 +371,7 @@ abstract class Tasty { tasty =>
 
     val Inlined: InlinedExtractor
     abstract class InlinedExtractor {
-      def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[Definition], Term)]
+      def unapply(x: Term)(implicit ctx: Context): Option[(Option[Term], List[Definition], Term)]
     }
 
     val SelectOuter: SelectOuterExtractor
diff --git a/tests/neg-with-compiler/quote-run-in-macro-1/quoted_1.scala b/tests/neg-with-compiler/quote-run-in-macro-1/quoted_1.scala
index 80b58e4c84bb..07dfdec021a8 100644
--- a/tests/neg-with-compiler/quote-run-in-macro-1/quoted_1.scala
+++ b/tests/neg-with-compiler/quote-run-in-macro-1/quoted_1.scala
@@ -3,8 +3,9 @@ import scala.quoted._
 import scala.quoted.Toolbox.Default._
 
 object Macros {
-  transparent def foo(i: => Int): Int = ~{
-    val y: Int = ('(i)).run
+  transparent def foo(i: => Int): Int = ~fooImpl('(i))
+  def fooImpl(i: Expr[Int]): Expr[Int] = {
+    val y: Int = i.run
     y.toExpr
   }
 }
diff --git a/tests/neg-with-compiler/quote-run-in-macro-2/quoted_1.scala b/tests/neg-with-compiler/quote-run-in-macro-2/quoted_1.scala
index 80b58e4c84bb..07dfdec021a8 100644
--- a/tests/neg-with-compiler/quote-run-in-macro-2/quoted_1.scala
+++ b/tests/neg-with-compiler/quote-run-in-macro-2/quoted_1.scala
@@ -3,8 +3,9 @@ import scala.quoted._
 import scala.quoted.Toolbox.Default._
 
 object Macros {
-  transparent def foo(i: => Int): Int = ~{
-    val y: Int = ('(i)).run
+  transparent def foo(i: => Int): Int = ~fooImpl('(i))
+  def fooImpl(i: Expr[Int]): Expr[Int] = {
+    val y: Int = i.run
     y.toExpr
   }
 }
diff --git a/tests/neg/i4433.scala b/tests/neg/i4433.scala
index 4f8226f55e64..71cbf64ac00e 100644
--- a/tests/neg/i4433.scala
+++ b/tests/neg/i4433.scala
@@ -1,7 +1,7 @@
 
 object Foo {
-  transparent def g(transparent p: Int => Boolean): Boolean = ~{
-    if(p(5)) '(true) // error
+  transparent def g(transparent p: Int => Boolean): Boolean = ~{ // error
+    if(p(5)) '(true)
     else '(false)
   }
 }
diff --git a/tests/pos/i4493-b.scala b/tests/neg/i4493-b.scala
similarity index 65%
rename from tests/pos/i4493-b.scala
rename to tests/neg/i4493-b.scala
index 25b043cb56ad..e73e8e1f61a6 100644
--- a/tests/pos/i4493-b.scala
+++ b/tests/neg/i4493-b.scala
@@ -1,6 +1,6 @@
 class Index[K]
 object Index {
-  transparent def succ[K](x: K): Unit = ~{
+  transparent def succ[K](x: K): Unit = ~{ // error
     implicit val t: quoted.Type[K] = '[K]
     '(new Index[K])
   }
diff --git a/tests/pos/i4493.scala b/tests/neg/i4493.scala
similarity index 68%
rename from tests/pos/i4493.scala
rename to tests/neg/i4493.scala
index 3ea8f4f23d5f..3752634ccfa5 100644
--- a/tests/pos/i4493.scala
+++ b/tests/neg/i4493.scala
@@ -1,6 +1,6 @@
 class Index[K]
 object Index {
-  transparent def succ[K]: Unit = ~{
+  transparent def succ[K]: Unit = ~{ // error
     implicit val t: quoted.Type[K] = '[K]
     '(new Index[K])
   }
diff --git a/tests/neg/quote-complex-top-splice.scala b/tests/neg/quote-complex-top-splice.scala
new file mode 100644
index 000000000000..e7c5324796ac
--- /dev/null
+++ b/tests/neg/quote-complex-top-splice.scala
@@ -0,0 +1,29 @@
+import Test.impl
+
+import scala.quoted._
+
+object Test {
+
+  transparent def foo1: Unit = ~{ // error
+    val x = 1
+    impl(x)
+  }
+
+  transparent def foo2: Unit = ~impl({ // error
+    val x = 1
+    x
+  })
+
+  transparent def foo3: Unit = ~impl({ // error
+    println("foo3")
+    3
+  })
+
+  transparent def foo4: Unit = ~{ // error
+    println("foo4")
+    impl(1)
+  }
+
+  def impl(i: Int): Expr[Unit] = '()
+
+}
diff --git a/tests/neg/quote-macro-complex-arg-0.scala b/tests/neg/quote-macro-complex-arg-0.scala
new file mode 100644
index 000000000000..d27dc66e6843
--- /dev/null
+++ b/tests/neg/quote-macro-complex-arg-0.scala
@@ -0,0 +1,6 @@
+import scala.quoted._
+
+object Macros {
+  transparent def foo(transparent i: Int, dummy: Int, j: Int): Int = ~bar(i + 1, '(j)) // error: i + 1 is not a parameter or field reference
+  def bar(x: Int, y: Expr[Int]): Expr[Int] = '{ ~x.toExpr + ~y }
+}
diff --git a/tests/neg/quote-splice-interpret-1.scala b/tests/neg/quote-splice-interpret-1.scala
new file mode 100644
index 000000000000..26fd25f5e299
--- /dev/null
+++ b/tests/neg/quote-splice-interpret-1.scala
@@ -0,0 +1,9 @@
+
+import scala.quoted._
+
+object Macros {
+  transparent def isZero(transparent n: Int): Boolean = ~{ // error
+    if (n == 0) '(true)
+    else '(false)
+  }
+}
diff --git a/tests/neg/tasty-macro-assert/quoted_1.scala b/tests/neg/tasty-macro-assert/quoted_1.scala
index 8900e1538fbe..bfc4dbe2341b 100644
--- a/tests/neg/tasty-macro-assert/quoted_1.scala
+++ b/tests/neg/tasty-macro-assert/quoted_1.scala
@@ -11,7 +11,7 @@ object Asserts {
 
   object Ops
 
-  transparent def macroAssert(cond: Boolean): Unit =
+  transparent def macroAssert(cond: => Boolean): Unit =
     ~impl('(cond))(TopLevelSplice.tastyContext) // FIXME infer TopLevelSplice.tastyContext within top level ~
 
   def impl(cond: Expr[Boolean])(implicit tasty: Tasty): Expr[Unit] = {
@@ -33,7 +33,7 @@ object Asserts {
     }
 
     tree match {
-      case Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil) =>
+      case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil)) =>
         '(assertTrue(~left.toExpr[Boolean])) // Buggy code. To generate the errors
       case _ =>
         '(assertTrue(~cond))
diff --git a/tests/run/tasty-linenumber/quoted_1.scala b/tests/pending/run/tasty-linenumber/quoted_1.scala
similarity index 100%
rename from tests/run/tasty-linenumber/quoted_1.scala
rename to tests/pending/run/tasty-linenumber/quoted_1.scala
diff --git a/tests/run/tasty-linenumber/quoted_2.scala b/tests/pending/run/tasty-linenumber/quoted_2.scala
similarity index 100%
rename from tests/run/tasty-linenumber/quoted_2.scala
rename to tests/pending/run/tasty-linenumber/quoted_2.scala
diff --git a/tests/pos-with-compiler/tasty/definitions.scala b/tests/pos-with-compiler/tasty/definitions.scala
index 95341ac8cfcf..f5e41f027188 100644
--- a/tests/pos-with-compiler/tasty/definitions.scala
+++ b/tests/pos-with-compiler/tasty/definitions.scala
@@ -78,7 +78,7 @@ object definitions {
     case Typed(expr: Term, tpt: TypeTree)
     case Assign(lhs: Term, rhs: Term)
     case Block(stats: List[Statement], expr: Term)
-    case Inlined(call: Term, bindings: List[Definition], expr: Term)
+    case Inlined(call: Option[Term], bindings: List[Definition], expr: Term)
     case Lambda(method: Term, tpt: Option[TypeTree])
     case If(cond: Term, thenPart: Term, elsePart: Term)
     case Match(scrutinee: Term, cases: List[CaseDef])
diff --git a/tests/pos/i4773.scala b/tests/pos/i4773.scala
new file mode 100644
index 000000000000..9ed2e098682b
--- /dev/null
+++ b/tests/pos/i4773.scala
@@ -0,0 +1,7 @@
+import scala.quoted._
+
+object Foo {
+  transparent def foo2(): Unit = ~foo2Impl()
+  def foo2Impl(): Expr[Unit] = '()
+  transparent def foo(): Unit = foo2()
+}
diff --git a/tests/pos/quote-lift-inline-params-b.scala b/tests/pos/quote-lift-inline-params-b.scala
index 66872399d155..d1c90d375183 100644
--- a/tests/pos/quote-lift-inline-params-b.scala
+++ b/tests/pos/quote-lift-inline-params-b.scala
@@ -1,7 +1,7 @@
 import scala.quoted.Expr
+import quoted.Liftable.{IntIsLiftable => _}
 object Macro {
   transparent def foo(transparent n: Int): Int = ~{
-    import quoted.Liftable.{IntIsLiftable => _}
     '(n)
   }
 }
\ No newline at end of file
diff --git a/tests/pos/quote-lift-inline-params/Macro_1.scala b/tests/pos/quote-lift-inline-params/Macro_1.scala
index 66872399d155..257adddc39e0 100644
--- a/tests/pos/quote-lift-inline-params/Macro_1.scala
+++ b/tests/pos/quote-lift-inline-params/Macro_1.scala
@@ -1,7 +1,7 @@
 import scala.quoted.Expr
 object Macro {
+  import quoted.Liftable.{IntIsLiftable => _}
   transparent def foo(transparent n: Int): Int = ~{
-    import quoted.Liftable.{IntIsLiftable => _}
     '(n)
   }
 }
\ No newline at end of file
diff --git a/tests/run-with-compiler/quote-impure-by-name.check b/tests/run-with-compiler/quote-impure-by-name.check
index 6616ccfa5430..d29945c196fa 100644
--- a/tests/run-with-compiler/quote-impure-by-name.check
+++ b/tests/run-with-compiler/quote-impure-by-name.check
@@ -1 +1,3 @@
-1 + {Index.zero["bar", scala.Tuple2["baz", scala.Unit]]}
+1 + {{ // inlined
+  Index.zero["bar", scala.Tuple2["baz", scala.Unit]]
+}}
diff --git a/tests/run-with-compiler/quote-splice-interpret-1/Macro_1.scala b/tests/run-with-compiler/quote-splice-interpret-1/Macro_1.scala
deleted file mode 100644
index 16a12855bc8f..000000000000
--- a/tests/run-with-compiler/quote-splice-interpret-1/Macro_1.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-import dotty.tools.dotc.ast.Trees.Import
-
-import scala.quoted._
-
-object Macros {
-  sealed trait Nat
-  case object Z extends Nat
-  case class S[N <: Nat]() extends Nat
-
-  transparent def isZero(transparent n: Int): Boolean = ~{
-    if (n == 0) '(true)
-    else '(false)
-  }
-
-}
diff --git a/tests/run-with-compiler/quote-splice-interpret-1/Test_2.scala b/tests/run-with-compiler/quote-splice-interpret-1/Test_2.scala
deleted file mode 100644
index 5a1b4b2b4c2a..000000000000
--- a/tests/run-with-compiler/quote-splice-interpret-1/Test_2.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-import Macros._
-object Test {
-  def main(args: Array[String]): Unit = {
-    println(isZero(0))
-    println(isZero(1))
-  }
-}
diff --git a/tests/run-with-compiler/tasty-positioned.check b/tests/run-with-compiler/tasty-positioned.check
new file mode 100644
index 000000000000..cccdff761382
--- /dev/null
+++ b/tests/run-with-compiler/tasty-positioned.check
@@ -0,0 +1,3 @@
+a
+b columns:6-25 lines:15-16
+Foo columns:16-19 lines:17-17
diff --git a/tests/run-with-compiler/tasty-positioned/quoted_1.scala b/tests/run-with-compiler/tasty-positioned/quoted_1.scala
new file mode 100644
index 000000000000..c7203a3b8cc3
--- /dev/null
+++ b/tests/run-with-compiler/tasty-positioned/quoted_1.scala
@@ -0,0 +1,37 @@
+import scala.quoted._
+
+import scala.tasty._
+
+case class Position(path: String, start: Int, end: Int,
+    startLine: Int, startColumn: Int, endLine: Int, endColumn: Int)
+
+case class Positioned[T](value: T, position: Position)
+
+object Positioned {
+
+  implicit transparent def apply[T](x: => T): Positioned[T] =
+    ~impl('(x))('[T], TopLevelSplice.tastyContext) // FIXME infer TopLevelSplice.tastyContext within top level ~
+
+  def impl[T](x: Expr[T])(implicit ev: Type[T], tasty: Tasty): Expr[Positioned[T]] = {
+    import tasty.{Position => _, _}
+    implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+    val pos = x.toTasty.pos
+
+    x.toTasty match {
+      case Term.Inlined(_, Nil, y) =>
+        val pos = y.pos
+
+        val path = pos.sourceFile.toString.toExpr
+        val start = pos.start.toExpr
+        val end = pos.end.toExpr
+        val startLine = pos.startLine.toExpr
+        val endLine = pos.endLine.toExpr
+        val startColumn = pos.startColumn.toExpr
+        val endColumn = pos.endColumn.toExpr
+
+        '(Positioned[T](~x, new Position(~path, ~start, ~end, ~startLine, ~startColumn, ~endLine, ~endColumn)))
+      case _ =>
+        '(Positioned[T](~x, new Position(null, -1, -1, -1, -1, -1, -1)))
+    }
+  }
+}
diff --git a/tests/run/tasty-positioned/quoted_2.scala b/tests/run-with-compiler/tasty-positioned/quoted_2.scala
similarity index 67%
rename from tests/run/tasty-positioned/quoted_2.scala
rename to tests/run-with-compiler/tasty-positioned/quoted_2.scala
index 4026b53b3ff2..dfeed79753fa 100644
--- a/tests/run/tasty-positioned/quoted_2.scala
+++ b/tests/run-with-compiler/tasty-positioned/quoted_2.scala
@@ -7,11 +7,11 @@ object Test {
       val pos = x.position
       println(s"${x.value} columns:${pos.startColumn}-${pos.endColumn} lines:${pos.startLine}-${pos.endLine}")
     }
-    printPos(Positioned(0))
-    printPos(10)
-    printPos(4530)
-    printPos(Positioned("acbvasdfa"))
-    printPos("acbvasdfa")
+//    printPos(Positioned(0)) // FIXME we cannot get possition of values that get inlined
+//    printPos(10)
+//    printPos(4530)
+//    printPos(Positioned("acbvasdfa"))
+//    printPos("acbvasdfa")
     printPos(
       """a
         |b""".stripMargin)
diff --git a/tests/run/i4735.check b/tests/run/i4735.check
new file mode 100644
index 000000000000..5d19833216d4
--- /dev/null
+++ b/tests/run/i4735.check
@@ -0,0 +1,28 @@
+<log> start loop
+0
+2
+4
+<log> start loop
+6
+8
+10
+<log> start loop
+12
+14
+16
+<log> start loop
+18
+20
+22
+<log> start loop
+24
+26
+28
+<log> start loop
+30
+32
+34
+<log> start loop
+36
+38
+40
diff --git a/tests/run/i4735/App_2.scala b/tests/run/i4735/App_2.scala
new file mode 100644
index 000000000000..3f374a321031
--- /dev/null
+++ b/tests/run/i4735/App_2.scala
@@ -0,0 +1,14 @@
+import scala.quoted._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val arr = Array.tabulate[Int](21)(x => x)
+    for (x <- new Unrolled(arr)) {
+      System.out.println(2*x)
+    }
+  }
+}
+
+class Unrolled(arr: Array[Int]) extends AnyVal {
+  transparent def foreach(f: => Int => Unit): Unit = Macro.unrolledForeach(3, arr, f)
+}
diff --git a/tests/run/i4735/Macro_1.scala b/tests/run/i4735/Macro_1.scala
new file mode 100644
index 000000000000..ffc609f8e3d2
--- /dev/null
+++ b/tests/run/i4735/Macro_1.scala
@@ -0,0 +1,34 @@
+import scala.annotation.tailrec
+import scala.quoted._
+
+object Macro {
+
+  transparent def unrolledForeach(transparent unrollSize: Int, seq: Array[Int], f: => Int => Unit): Unit = // or f: Int => Unit
+    ~unrolledForeachImpl(unrollSize, '(seq), '(f))
+
+  private def unrolledForeachImpl(unrollSize: Int, seq: Expr[Array[Int]], f: Expr[Int => Unit]): Expr[Unit] = '{
+    val size = (~seq).length
+    assert(size % (~unrollSize.toExpr) == 0) // for simplicity of the implementation
+    var i = 0
+    while (i < size) {
+      println("<log> start loop")
+      ~{
+        for (j <- new UnrolledRange(0, unrollSize)) '{
+          val element = (~seq)(i + ~j.toExpr)
+          ~f('(element)) // or `(~f)(element)` if `f` should not be inlined
+        }
+      }
+      i += ~unrollSize.toExpr
+    }
+
+  }
+
+  private class UnrolledRange(start: Int, end: Int) {
+    def foreach(f: Int => Expr[Unit]): Expr[Unit] = {
+      @tailrec def loop(i: Int, acc: Expr[Unit]): Expr[Unit] =
+        if (i >= 0) loop(i - 1, '{ ~f(i); ~acc })
+      else acc
+      loop(end - 1, '())
+    }
+  }
+}
diff --git a/tests/run/quote-and-splice/Macros_1.scala b/tests/run/quote-and-splice/Macros_1.scala
index 08259d650966..7e35671af6eb 100644
--- a/tests/run/quote-and-splice/Macros_1.scala
+++ b/tests/run/quote-and-splice/Macros_1.scala
@@ -21,7 +21,7 @@ object Macros {
 
   def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
     if (n == 0) '(1.0)
-  else if (n == 1) x
-  else if (n % 2 == 0) '{ { val y = ~x * ~x; ~powerCode(n / 2, '(y)) } }
-  else '{ ~x * ~powerCode(n - 1, x) }
+    else if (n == 1) x
+    else if (n % 2 == 0) '{ { val y = ~x * ~x; ~powerCode(n / 2, '(y)) } }
+    else '{ ~x * ~powerCode(n - 1, x) }
 }
diff --git a/tests/run/quote-sep-comp-2/Macro_1.scala b/tests/run/quote-sep-comp-2/Macro_1.scala
new file mode 100644
index 000000000000..dadd4d890a99
--- /dev/null
+++ b/tests/run/quote-sep-comp-2/Macro_1.scala
@@ -0,0 +1,5 @@
+import scala.quoted._
+
+object Macros {
+  def assertImpl(expr: Expr[Boolean]) = '{ println(~expr) }
+}
diff --git a/tests/run/quote-sep-comp-2/Test_2.scala b/tests/run/quote-sep-comp-2/Test_2.scala
new file mode 100644
index 000000000000..6d20480ae69a
--- /dev/null
+++ b/tests/run/quote-sep-comp-2/Test_2.scala
@@ -0,0 +1,11 @@
+
+object Test {
+
+  transparent def assert2(expr: => Boolean): Unit =  ~Macros.assertImpl('(expr))
+
+  def main(args: Array[String]): Unit = {
+    val x = 1
+    assert2(x != 0)
+    assert2(x == 0)
+  }
+}
diff --git a/tests/run/quote-simple-macro.check b/tests/run/quote-simple-macro.check
index b8626c4cff28..00750edc07d6 100644
--- a/tests/run/quote-simple-macro.check
+++ b/tests/run/quote-simple-macro.check
@@ -1 +1 @@
-4
+3
diff --git a/tests/run/quote-simple-macro/quoted_1.scala b/tests/run/quote-simple-macro/quoted_1.scala
index 7d1549148650..04a49e3289d2 100644
--- a/tests/run/quote-simple-macro/quoted_1.scala
+++ b/tests/run/quote-simple-macro/quoted_1.scala
@@ -1,6 +1,6 @@
 import scala.quoted._
 
 object Macros {
-  transparent def foo(transparent i: Int, dummy: Int, j: Int): Int = ~bar(i + 1, '(j))
+  transparent def foo(transparent i: Int, dummy: Int, j: Int): Int = ~bar(i, '(j))
   def bar(x: Int, y: Expr[Int]): Expr[Int] = '{ ~x.toExpr + ~y }
 }
diff --git a/tests/run/tasty-extractors-1.check b/tests/run/tasty-extractors-1.check
index 000e7a57862d..1d44a67395da 100644
--- a/tests/run/tasty-extractors-1.check
+++ b/tests/run/tasty-extractors-1.check
@@ -16,105 +16,105 @@ Type.ConstantType(Constant.Double(2.2))
 Term.Literal(Constant.String("abc"))
 Type.ConstantType(Constant.String("abc"))
 
-Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.String("abc"))))
+Term.Inlined(None, Nil, Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.String("abc")))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Typed(Term.Literal(Constant.Int(8)), TypeTree.TypeIdent("Int"))
+Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(8)), TypeTree.TypeIdent("Int")))
 Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))
 
-Term.Typed(Term.Literal(Constant.Byte(8)), TypeTree.TypeIdent("Byte"))
+Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Byte(8)), TypeTree.TypeIdent("Byte")))
 Type.SymRef(ClassDef("Byte", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))
 
-Term.Typed(Term.Literal(Constant.Short(8)), TypeTree.TypeIdent("Short"))
+Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Short(8)), TypeTree.TypeIdent("Short")))
 Type.SymRef(ClassDef("Short", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))
 
 Term.Literal(Constant.Char(a))
 Type.ConstantType(Constant.Char(a))
 
-Term.Block(List(Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2))), Term.Literal(Constant.Int(3)))
+Term.Inlined(None, Nil, Term.Block(List(Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2))), Term.Literal(Constant.Int(3))))
 Type.ConstantType(Constant.Int(3))
 
-Term.If(Term.Typed(Term.Literal(Constant.Boolean(true)), TypeTree.TypeIdent("Boolean")), Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2)))
+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))))
 Type.SymRef(ClassDef("Int", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Match(Term.Literal(Constant.String("a")), List(CaseDef(Pattern.Value(Term.Literal(Constant.String("a"))), None, Term.Block(Nil, Term.Literal(Constant.Unit())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Match(Term.Literal(Constant.String("b")), List(CaseDef(Pattern.Bind("n", Pattern.Value(Term.Ident("_"))), None, Term.Block(Nil, Term.Literal(Constant.Unit())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Match(Term.Literal(Constant.String("e")), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Block(Nil, Term.Literal(Constant.Unit())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Match(Term.Literal(Constant.String("f")), List(CaseDef(Pattern.TypeTest(TypeTree.TypeIdent("String")), None, Term.Block(Nil, Term.Literal(Constant.Unit())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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())))))
+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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ValDef("a", TypeTree.Synthetic(), 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()))))))
+Term.Inlined(None, Nil, Term.Block(List(ValDef("a", TypeTree.Synthetic(), 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())))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Match(Term.Ident("Nil"), List(CaseDef(Pattern.Unapply(Term.TypeApply(Term.Select(Term.Ident("List"), "unapplySeq", Some(Signature(List(scala.collection.Seq), scala.Some))), List(TypeTree.Synthetic())), 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())))))
+Term.Inlined(None, Nil, Term.Match(Term.Ident("Nil"), List(CaseDef(Pattern.Unapply(Term.TypeApply(Term.Select(Term.Ident("List"), "unapplySeq", Some(Signature(List(scala.collection.Seq), scala.Some))), List(TypeTree.Synthetic())), 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()))))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Try(Term.Literal(Constant.Int(1)), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Block(Nil, Term.Literal(Constant.Unit())))), None)
+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))
 Type.OrType(Type.SymRef(ClassDef("Int", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))), Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))))
 
-Term.Try(Term.Literal(Constant.Int(2)), Nil, Some(Term.Literal(Constant.Unit())))
+Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(2)), Nil, Some(Term.Literal(Constant.Unit()))))
 Type.ConstantType(Constant.Int(2))
 
-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())))
+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()))))
 Type.OrType(Type.SymRef(ClassDef("Int", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))), Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))))
 
-Term.Apply(Term.Select(Term.Literal(Constant.String("a")), "==", Some(Signature(List(java.lang.Object), scala.Boolean))), List(Term.Literal(Constant.String("b"))))
+Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.Literal(Constant.String("a")), "==", Some(Signature(List(java.lang.Object), scala.Boolean))), List(Term.Literal(Constant.String("b")))))
 Type.SymRef(ClassDef("Boolean", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Object")), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)
+Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Object")), "<init>", Some(Signature(Nil, java.lang.Object))), Nil))
 Type.SymRef(ClassDef("Object", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("lang", _), NoPrefix())))
 
-Term.Apply(Term.Select(Term.Ident("Int"), "box", Some(Signature(List(scala.Int), java.lang.Integer))), List(Term.NamedArg("x", Term.Literal(Constant.Int(9)))))
+Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.Ident("Int"), "box", Some(Signature(List(scala.Int), java.lang.Integer))), List(Term.NamedArg("x", Term.Literal(Constant.Int(9))))))
 Type.SymRef(ClassDef("Integer", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("lang", _), NoPrefix())))
 
-Term.Apply(Term.TypeApply(Term.Select(Term.Ident("Ordering"), "apply", Some(Signature(List(scala.math.Ordering), scala.math.Ordering))), List(TypeTree.TypeIdent("Int"))), List(Term.Ident("Int")))
+Term.Inlined(None, Nil, Term.Apply(Term.TypeApply(Term.Select(Term.Ident("Ordering"), "apply", Some(Signature(List(scala.math.Ordering), scala.math.Ordering))), List(TypeTree.TypeIdent("Int"))), List(Term.Ident("Int"))))
 Type.AppliedType(Type.SymRef(ClassDef("Ordering", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("math", _), NoPrefix()))), List(Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))))
 
-Term.Block(List(ValDef("a", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ValDef("a", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ValDef("b", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ValDef("b", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(DefDef("f1", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(DefDef("f1", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(DefDef("f2", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Return(Term.Literal(Constant.Int(4)))))), Term.Literal(Constant.Unit()))
+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())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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()))
+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())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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"), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Ident("j")))))), Term.Literal(Constant.Unit()))
+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"), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Ident("j")))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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.Synthetic(), Some(Term.Literal(Constant.Int(9))))), Term.Literal(Constant.Unit()))
+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.Synthetic(), Some(Term.Literal(Constant.Int(9))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(DefDef("f6", List(TypeDef("T", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), List(List(ValDef("x", TypeTree.TypeIdent("T"), None))), TypeTree.TypeIdent("T"), Some(Term.Ident("x")))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(DefDef("f6", List(TypeDef("T", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), List(List(ValDef("x", TypeTree.TypeIdent("T"), None))), TypeTree.TypeIdent("T"), Some(Term.Ident("x")))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(DefDef("f7", List(TypeDef("T", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), List(List(ValDef("x", TypeTree.TypeIdent("T"), None))), TypeTree.Singleton(Term.Ident("x")), Some(Term.Ident("x")))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(DefDef("f7", List(TypeDef("T", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), List(List(ValDef("x", TypeTree.TypeIdent("T"), None))), TypeTree.Singleton(Term.Ident("x")), Some(Term.Ident("x")))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(DefDef("f8", Nil, List(List(ValDef("i", TypeTree.Annotated(TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.TypeIdent("Int"))), Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, scala.annotation.internal.Repeated))), 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.Synthetic()))))
+Term.Inlined(None, Nil, Term.Block(List(DefDef("f8", Nil, List(List(ValDef("i", TypeTree.Annotated(TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.TypeIdent("Int"))), Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, scala.annotation.internal.Repeated))), 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.Synthetic())))))
 Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))
 
-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()))
+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())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
diff --git a/tests/run/tasty-extractors-2.check b/tests/run/tasty-extractors-2.check
index 582c6e072cb8..aefe23bdf1f6 100644
--- a/tests/run/tasty-extractors-2.check
+++ b/tests/run/tasty-extractors-2.check
@@ -1,111 +1,105 @@
-Term.Block(List(ValDef("x", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(1))))), Term.Assign(Term.Ident("x"), Term.Literal(Constant.Int(2))))
+Term.Inlined(None, Nil, Term.Block(List(ValDef("x", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(1))))), Term.Assign(Term.Ident("x"), Term.Literal(Constant.Int(2)))))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None))
+Term.Inlined(None, Nil, Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None)))
 Type.AppliedType(Type.SymRef(ClassDef("Function1", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))), List(Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix())))), Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))))
 
-Term.Ident("???")
+Term.Inlined(None, Nil, Term.Ident("???"))
 Type.SymRef(DefDef("???", _, _, _, _), Type.SymRef(ValDef("Predef", _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))))
 
-Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.Singleton(Term.Literal(Constant.Int(1))))
+Term.Literal(Constant.Int(1))
 Type.ConstantType(Constant.Int(1))
 
-Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.TypeIdent("Int"))
+Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.TypeIdent("Int")))
 Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))
 
-Term.Typed(Term.Ident("Nil"), TypeTree.Applied(TypeTree.TypeIdent("List"), List(TypeTree.TypeIdent("Int"))))
+Term.Inlined(None, Nil, Term.Typed(Term.Ident("Nil"), TypeTree.Applied(TypeTree.TypeIdent("List"), List(TypeTree.TypeIdent("Int")))))
 Type.AppliedType(Type.SymRef(ClassDef("List", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("immutable", _), NoPrefix()))), List(Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))))
 
-Term.Typed(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Baz")), "<init>", Some(Signature(Nil, Baz))), Nil), TypeTree.And(TypeTree.TypeIdent("Foo"), TypeTree.TypeIdent("Bar")))
+Term.Inlined(None, Nil, Term.Typed(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Baz")), "<init>", Some(Signature(Nil, Baz))), Nil), TypeTree.And(TypeTree.TypeIdent("Foo"), TypeTree.TypeIdent("Bar"))))
 Type.AndType(Type.SymRef(ClassDef("Foo", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("<empty>", _), NoPrefix()))), Type.SymRef(ClassDef("Bar", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("<empty>", _), NoPrefix()))))
 
-Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.Or(TypeTree.TypeIdent("Int"), TypeTree.TypeIdent("String")))
+Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.Or(TypeTree.TypeIdent("Int"), TypeTree.TypeIdent("String"))))
 Type.OrType(Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix())))), Type.SymRef(TypeDef("String", _), Type.SymRef(ValDef("Predef", _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))))
 
-Term.Block(List(Import(Term.Select(Term.Ident("scala"), "collection", None), List(SimpleSelector(Id("mutable"))))), Term.Literal(Constant.Int(1)))
-Type.ConstantType(Constant.Int(1))
-
-Term.Block(List(Import(Term.Select(Term.Ident("scala"), "collection", None), List(SimpleSelector(Id("mutable")), SimpleSelector(Id("immutable"))))), Term.Literal(Constant.Int(2)))
-Type.ConstantType(Constant.Int(2))
-
-Term.Block(List(Import(Term.Select(Term.Ident("scala"), "collection", None), List(RenameSelector(Id("mutable"), Id("mut"))))), Term.Literal(Constant.Int(3)))
-Type.ConstantType(Constant.Int(3))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, Nil)), Term.Literal(Constant.Unit())))
+Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(Import(Term.Select(Term.Ident("scala"), "collection", None), List(OmitSelector(Id("mutable"))))), Term.Literal(Constant.Int(4)))
-Type.ConstantType(Constant.Int(4))
+Term.Inlined(None, Nil, Term.Block(List(ValDef("Foo", TypeTree.TypeIdent("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo$")), "<init>", Some(Signature(Nil, Test$._$Foo$))), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), Nil)), Term.Literal(Constant.Unit())))
+Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, Nil)), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ValDef("Foo", TypeTree.TypeIdent("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo$")), "<init>", Some(Signature(Nil, Test$._$Foo$))), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), Nil)), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeTree.TypeIdent("Int"))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.TypeIdent("Null"), TypeTree.TypeIdent("Object")))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(TypeDef("Foo", TypeTree.TypeIdent("Int"))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.TypeIdent("Null"), TypeTree.TypeIdent("Object")))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.TermSelect(Term.Select(Term.Ident("_root_"), "scala", None), "Product")), None, List(DefDef("copy", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil))), DefDef("hashCode", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(394005536)))), DefDef("equals", Nil, List(List(ValDef("x$0", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Apply(Term.Select(Term.Apply(Term.Select(Term.This(Some(Id("Foo"))), "eq", Some(Signature(List(java.lang.Object), scala.Boolean))), List(Term.TypeApply(Term.Select(Term.Ident("x$0"), "asInstanceOf", Some(Signature(Nil, java.lang.Object))), List(TypeTree.Synthetic())))), "||", Some(Signature(List(scala.Boolean), scala.Boolean))), List(Term.Match(Term.Ident("x$0"), List(CaseDef(Pattern.Bind("x$0", Pattern.TypeTest(TypeTree.Synthetic())), None, Term.Literal(Constant.Boolean(true))), CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Literal(Constant.Boolean(false))))))))), DefDef("toString", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Apply(Term.Ident("_toString"), List(Term.This(Some(Id("Foo"))))))), DefDef("canEqual", Nil, List(List(ValDef("that", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.TypeApply(Term.Select(Term.Ident("that"), "isInstanceOf", Some(Signature(Nil, scala.Boolean))), List(TypeTree.Synthetic())))), DefDef("productArity", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0)))), DefDef("productPrefix", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.String("Foo")))), DefDef("productElement", Nil, List(List(ValDef("n", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Match(Term.Ident("n"), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Apply(Term.Ident("throw"), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(List(java.lang.String), java.lang.IndexOutOfBoundsException))), List(Term.Apply(Term.Select(Term.Ident("n"), "toString", Some(Signature(Nil, java.lang.String))), Nil)))))))))))), ValDef("Foo", TypeTree.TypeIdent("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo$")), "<init>", Some(Signature(Nil, Test$._$Foo$))), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.Synthetic()))), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), List(DefDef("apply", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil))), DefDef("unapply", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Boolean(true))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo1", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo1", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo3", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None))), ValDef("Foo3", TypeTree.TypeIdent("Foo3$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo3$")), "<init>", Some(Signature(Nil, Test$._$Foo3$))), Nil))), ClassDef("Foo3$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo3")), None)), List(DefDef("$lessinit$greater$default$1", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(5))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo3", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None))), ValDef("Foo3", TypeTree.TypeIdent("Foo3$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo3$")), "<init>", Some(Signature(Nil, Test$._$Foo3$))), Nil))), ClassDef("Foo3$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo3")), None)), List(DefDef("$lessinit$greater$default$1", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(5))))))), Term.Literal(Constant.Unit()))
+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.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo4", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None)), List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit()))
+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.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None))), ValDef("Foo5", TypeTree.TypeIdent("Foo5$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo5$")), "<init>", Some(Signature(Nil, Test$._$Foo5$))), Nil))), ClassDef("Foo5$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), 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.Synthetic(), Some(Term.Ident("a")))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo5", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None)), List(ValDef("b", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None))), ValDef("Foo5", TypeTree.TypeIdent("Foo5$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo5$")), "<init>", Some(Signature(Nil, Test$._$Foo5$))), Nil))), ClassDef("Foo5$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), 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.Synthetic(), Some(Term.Ident("a")))))), Term.Literal(Constant.Unit()))
+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.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-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.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo7", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Block(List(Term.Apply(Term.Select(Term.This(Some(Id("Foo7"))), "<init>", Some(Signature(List(scala.Int), Test$._$Foo7))), List(Term.Literal(Constant.Int(6))))), Term.Literal(Constant.Unit()))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo8", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo8", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo10", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(9))))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo10", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(9))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo11", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(10)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo11", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(10)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo12", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(11))))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo12", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(11))))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo")), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil)), None, Nil)), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo")), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil)), None, Nil)), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(TypeTree.Synthetic()), None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.TypeIdent("Foo2")), None, Nil)), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(TypeTree.Synthetic()), None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.TypeIdent("Foo2")), None, Nil)), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("i", TypeTree.Synthetic(), None))), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo")), "<init>", Some(Signature(List(scala.Int), Test$._$Foo))), List(Term.Literal(Constant.Int(1))))), None, Nil)), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("i", TypeTree.Synthetic(), None))), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.TypeIdent("Foo")), "<init>", Some(Signature(List(scala.Int), Test$._$Foo))), List(Term.Literal(Constant.Int(1))))), None, Nil)), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("X", TypeTree.TypeIdent("Int")))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Foo"), None))), TypeTree.TermSelect(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("X", TypeTree.TypeIdent("Int")))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.TypeIdent("Foo"), None))), TypeTree.TermSelect(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("X", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic())))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.Refined(TypeTree.TypeIdent("Foo"), List(TypeDef("X", TypeTree.TypeIdent("Int")))), None))), TypeTree.TermSelect(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("X", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic())))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.Refined(TypeTree.TypeIdent("Foo"), List(TypeDef("X", TypeTree.TypeIdent("Int")))), None))), TypeTree.TermSelect(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
-Term.Block(List(ValDef("lambda", TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.TypeIdent("Int"), TypeTree.TypeIdent("Int"))), Some(Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None))))), Term.Literal(Constant.Unit()))
+Term.Inlined(None, Nil, Term.Block(List(ValDef("lambda", TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.TypeIdent("Int"), TypeTree.TypeIdent("Int"))), Some(Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None))))), Term.Literal(Constant.Unit())))
 Type.SymRef(ClassDef("Unit", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))
 
diff --git a/tests/run/tasty-extractors-2/quoted_2.scala b/tests/run/tasty-extractors-2/quoted_2.scala
index d55a9daa7000..f2e9908649b9 100644
--- a/tests/run/tasty-extractors-2/quoted_2.scala
+++ b/tests/run/tasty-extractors-2/quoted_2.scala
@@ -11,10 +11,6 @@ object Test {
     printTree(Nil: List[Int])
     printTree(new Baz: Foo & Bar)
     printTree(1: Int | String)
-    printTree { import scala.collection.mutable; 1 }
-    printTree { import scala.collection.{mutable, immutable}; 2 }
-    printTree { import scala.collection.{mutable => mut}; 3 }
-    printTree { import scala.collection.{mutable => _}; 4 }
     printTree { class Foo }
     printTree { object Foo }
     printTree { type Foo }
@@ -24,14 +20,14 @@ object Test {
     printTree { class Foo { final def a = 0 } }
     printTree { class Foo { private[Foo] def a = 0 } }
     printTree { class Foo { protected[Foo] def a = 0 } }
-    // printTree { case class Foo() } // FIXME: issue #4396
+    printTree { case class Foo() }
     printTree { class Foo1(a: Int) }
     printTree { class Foo2(val b: Int) }
     printTree { class Foo3(a: Int = 5) }
     printTree { class Foo4(a: Int)(b: Int) }
     printTree { class Foo5(a: Int)(b: Int = a) }
     printTree { class Foo6(a: Int)(b: a.type) }
-    //    printTree { class Foo7(a: Int) { def this() = this(6) } }
+    printTree { class Foo7(a: Int) { def this() = this(6) } }
     printTree { class Foo8 { println(0) } }
     printTree { class Foo10 { val a = 9 } }
     printTree { class Foo11 { var a = 10 } }
diff --git a/tests/run/tasty-extractors-types.check b/tests/run/tasty-extractors-types.check
index 6563bf5bfc42..1eb1d3cef256 100644
--- a/tests/run/tasty-extractors-types.check
+++ b/tests/run/tasty-extractors-types.check
@@ -1,12 +1,12 @@
-TypeTree.TypeIdent("Int")
+TypeTree.Synthetic()
 Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))
 
-TypeTree.Applied(TypeTree.TypeIdent("List"), List(TypeTree.TypeIdent("String")))
+TypeTree.Synthetic()
 Type.AppliedType(Type.SymRef(ClassDef("List", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("immutable", _), NoPrefix()))), List(Type.SymRef(TypeDef("String", _), Type.SymRef(ValDef("Predef", _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix()))))))
 
-TypeTree.Applied(TypeTree.TypeIdent("Map"), List(TypeTree.TypeIdent("String"), TypeTree.TypeIdent("Int")))
+TypeTree.Synthetic()
 Type.AppliedType(Type.SymRef(ClassDef("Map", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("immutable", _), NoPrefix()))), List(Type.SymRef(TypeDef("String", _), Type.SymRef(ValDef("Predef", _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))), Type.SymRef(ClassDef("Int", _, _, _, _), Type.SymRef(PackageDef("scala", _), Type.ThisType(Type.SymRef(PackageDef("<root>", _), NoPrefix()))))))
 
-TypeTree.Applied(TypeTree.TypeIdent("Map"), List(TypeTree.TypeIdent("String"), TypeTree.TypeIdent("I")))
+TypeTree.Synthetic()
 Type.AppliedType(Type.SymRef(ClassDef("Map", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("immutable", _), NoPrefix()))), List(Type.SymRef(TypeDef("String", _), Type.SymRef(ValDef("Predef", _, _), Type.ThisType(Type.SymRef(PackageDef("scala", _), NoPrefix())))), Type.SymRef(TypeDef("I", _), NoPrefix())))
 
diff --git a/tests/run/tasty-macro-assert/quoted_1.scala b/tests/run/tasty-macro-assert/quoted_1.scala
index 2a5dd386119b..212c27732280 100644
--- a/tests/run/tasty-macro-assert/quoted_1.scala
+++ b/tests/run/tasty-macro-assert/quoted_1.scala
@@ -11,7 +11,7 @@ object Asserts {
 
   object Ops
 
-  transparent def macroAssert(cond: Boolean): Unit =
+  transparent def macroAssert(cond: => Boolean): Unit =
     ~impl('(cond))(TopLevelSplice.tastyContext) // FIXME infer TopLevelSplice.tastyContext within top level ~
 
   def impl(cond: Expr[Boolean])(implicit tasty: Tasty): Expr[Unit] = {
@@ -33,7 +33,7 @@ object Asserts {
     }
 
     tree match {
-      case Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil) =>
+      case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil)) =>
         op match {
           case "===" => '(assertEquals(~left.toExpr[Any], ~right.toExpr[Any]))
           case "!==" => '(assertNotEquals(~left.toExpr[Any], ~right.toExpr[Any]))
diff --git a/tests/run/tasty-positioned.check b/tests/run/tasty-positioned.check
deleted file mode 100644
index 0c43c2d3a4f1..000000000000
--- a/tests/run/tasty-positioned.check
+++ /dev/null
@@ -1,8 +0,0 @@
-0 columns:24-25 lines:9-9
-10 columns:13-15 lines:10-10
-4530 columns:13-17 lines:11-11
-acbvasdfa columns:24-35 lines:12-12
-acbvasdfa columns:13-24 lines:13-13
-a
-b columns:6-25 lines:15-16
-Foo columns:16-19 lines:17-17
diff --git a/tests/run/tasty-positioned/quoted_1.scala b/tests/run/tasty-positioned/quoted_1.scala
deleted file mode 100644
index 7f4ecc09b701..000000000000
--- a/tests/run/tasty-positioned/quoted_1.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-import scala.quoted._
-
-import scala.tasty._
-
-case class Position(path: String, start: Int, end: Int,
-    startLine: Int, startColumn: Int, endLine: Int, endColumn: Int)
-
-case class Positioned[T](value: T, position: Position)
-
-object Positioned {
-
-  implicit transparent def apply[T](x: T): Positioned[T] =
-    ~impl('(x))('[T], TopLevelSplice.tastyContext) // FIXME infer TopLevelSplice.tastyContext within top level ~
-
-  def impl[T](x: Expr[T])(implicit ev: Type[T], tasty: Tasty): Expr[Positioned[T]] = {
-    import tasty.{Position => _, _}
-
-    val pos = x.toTasty.pos
-
-    val path = pos.sourceFile.toString.toExpr
-    val start = pos.start.toExpr
-    val end = pos.end.toExpr
-    val startLine = pos.startLine.toExpr
-    val endLine = pos.endLine.toExpr
-    val startColumn = pos.startColumn.toExpr
-    val endColumn = pos.endColumn.toExpr
-
-    '(Positioned[T](~x, new Position(~path, ~start, ~end, ~startLine, ~startColumn, ~endLine, ~endColumn)))
-  }
-}