diff --git a/bench/tests/power-macro/PowerMacro.scala b/bench/tests/power-macro/PowerMacro.scala
index 74147d0293d5..042f212c9aa4 100644
--- a/bench/tests/power-macro/PowerMacro.scala
+++ b/bench/tests/power-macro/PowerMacro.scala
@@ -2,11 +2,11 @@ import scala.quoted.Expr
 
 object PowerMacro {
 
-  inline def power(inline n: Long, x: Double) = ~powerCode(n, '(x))
+  inline def power(inline n: Long, x: Double) = ${powerCode(n, '{x})}
 
   def powerCode(n: Long, x: Expr[Double]): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode(n / 2, '(y)) }
-    else '{ ~x * ~powerCode(n - 1, x) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ val y = $x * $x; ${powerCode(n / 2, '{y})} }
+    else '{ $x * ${powerCode(n - 1, x)} }
 
 }
diff --git a/community-build/community-projects/minitest b/community-build/community-projects/minitest
index 58292b4ae89a..01ca3a595248 160000
--- a/community-build/community-projects/minitest
+++ b/community-build/community-projects/minitest
@@ -1 +1 @@
-Subproject commit 58292b4ae89a061a7e44bceb95983970be6fc639
+Subproject commit 01ca3a595248e99973aa46e07fb9bd1626306790
diff --git a/community-build/community-projects/scalatest b/community-build/community-projects/scalatest
index d4fbd597712c..8e87031d1674 160000
--- a/community-build/community-projects/scalatest
+++ b/community-build/community-projects/scalatest
@@ -1 +1 @@
-Subproject commit d4fbd597712cc74961d5200cb88ec447ea6aa3c6
+Subproject commit 8e87031d16741022bac42d2562961ac9092ca91a
diff --git a/community-build/community-projects/sourcecode b/community-build/community-projects/sourcecode
index bed617b04c06..58f0d4d6c672 160000
--- a/community-build/community-projects/sourcecode
+++ b/community-build/community-projects/sourcecode
@@ -1 +1 @@
-Subproject commit bed617b04c066517fddd235c73f8b5db3bdc0950
+Subproject commit 58f0d4d6c67211337c795e2c208d261280cd5a3e
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 516028ec9f1f..68e13de6ccce 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1313,11 +1313,15 @@ object desugar {
     val desugared = tree match {
       case SymbolLit(str) =>
         Literal(Constant(scala.Symbol(str)))
-      case Quote(expr) =>
-        if (expr.isType)
-          TypeApply(ref(defn.QuotedType_applyR), List(expr))
+      case Quote(t) =>
+        if (t.isType)
+          TypeApply(ref(defn.QuotedType_applyR), List(t))
         else
-          Apply(ref(defn.QuotedExpr_applyR), expr)
+          Apply(ref(defn.QuotedExpr_applyR), t)
+      case Splice(expr) =>
+        Select(expr, nme.splice)
+      case TypSplice(expr) =>
+        Select(expr, tpnme.splice)
       case InterpolatedString(id, segments) =>
         val strs = segments map {
           case ts: Thicket => ts.trees.head
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 00d0b9fbbcc9..b4e85704e88a 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -16,8 +16,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   abstract class OpTree(implicit @constructorOnly src: SourceFile) extends Tree {
     def op: Ident
-    override def isTerm: Boolean = op.name.isTermName
-    override def isType: Boolean = op.name.isTypeName
+    override def isTerm: Boolean = op.isTerm
+    override def isType: Boolean = op.isType
   }
 
   /** A typed subtree of an untyped tree needs to be wrapped in a TypedSplice
@@ -84,10 +84,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   case class InfixOp(left: Tree, op: Ident, right: Tree)(implicit @constructorOnly src: SourceFile) extends OpTree
   case class PostfixOp(od: Tree, op: Ident)(implicit @constructorOnly src: SourceFile) extends OpTree
-  case class PrefixOp(op: Ident, od: Tree)(implicit @constructorOnly src: SourceFile) extends OpTree {
-    override def isType: Boolean = op.isType
-    override def isTerm: Boolean = op.isTerm
-  }
+  case class PrefixOp(op: Ident, od: Tree)(implicit @constructorOnly src: SourceFile) extends OpTree
   case class Parens(t: Tree)(implicit @constructorOnly src: SourceFile) extends ProxyTree {
     def forwardTo: Tree = t
   }
@@ -96,7 +93,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = !isTerm
   }
   case class Throw(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
-  case class Quote(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class Quote(t: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class Splice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class TypSplice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
   case class DoWhile(body: Tree, cond: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
   case class ForYield(enums: List[Tree], expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
   case class ForDo(enums: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
@@ -493,9 +492,17 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Throw if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Throw(expr)(tree.source))
     }
-    def Quote(tree: Tree)(expr: Tree)(implicit ctx: Context): TermTree = tree match {
-      case tree: Quote if expr eq tree.expr => tree
-      case _ => finalize(tree, untpd.Quote(expr)(tree.source))
+    def Quote(tree: Tree)(t: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: Quote if t eq tree.t => tree
+      case _ => finalize(tree, untpd.Quote(t)(tree.source))
+    }
+    def Splice(tree: Tree)(expr: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: Splice if expr eq tree.expr => tree
+      case _ => finalize(tree, untpd.Splice(expr)(tree.source))
+    }
+    def TypSplice(tree: Tree)(expr: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: TypSplice if expr eq tree.expr => tree
+      case _ => finalize(tree, untpd.TypSplice(expr)(tree.source))
     }
     def DoWhile(tree: Tree)(body: Tree, cond: Tree)(implicit ctx: Context): TermTree = tree match {
       case tree: DoWhile if (body eq tree.body) && (cond eq tree.cond) => tree
@@ -557,8 +564,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.Tuple(tree)(transform(trees))
       case Throw(expr) =>
         cpy.Throw(tree)(transform(expr))
-      case Quote(expr) =>
-        cpy.Quote(tree)(transform(expr))
+      case Quote(t) =>
+        cpy.Quote(tree)(transform(t))
+      case Splice(expr) =>
+        cpy.Splice(tree)(transform(expr))
+      case TypSplice(expr) =>
+        cpy.TypSplice(tree)(transform(expr))
       case DoWhile(body, cond) =>
         cpy.DoWhile(tree)(transform(body), transform(cond))
       case ForYield(enums, expr) =>
@@ -606,7 +617,11 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, trees)
       case Throw(expr) =>
         this(x, expr)
-      case Quote(expr) =>
+      case Quote(t) =>
+        this(x, t)
+      case Splice(expr) =>
+        this(x, expr)
+      case TypSplice(expr) =>
         this(x, expr)
       case DoWhile(body, cond) =>
         this(this(x, body), cond)
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 1bc6fcdb737b..2e4f65d4cc5e 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -707,7 +707,7 @@ class Definitions {
   def QuotedExprModule(implicit ctx: Context): Symbol = QuotedExprClass.companionModule
     lazy val QuotedExpr_applyR: TermRef = QuotedExprModule.requiredMethodRef(nme.apply)
     def QuotedExpr_apply(implicit ctx: Context): Symbol = QuotedExpr_applyR.symbol
-    lazy val QuotedExpr_~ : TermSymbol = QuotedExprClass.requiredMethod(nme.UNARY_~)
+    lazy val QuotedExpr_splice : TermSymbol = QuotedExprClass.requiredMethod(nme.splice)
 
   lazy val QuotedExprsModule: TermSymbol = ctx.requiredModule("scala.quoted.Exprs")
   def QuotedExprsClass(implicit ctx: Context): ClassSymbol = QuotedExprsModule.asClass
@@ -715,8 +715,8 @@ class Definitions {
   lazy val QuotedTypeType: TypeRef = ctx.requiredClassRef("scala.quoted.Type")
   def QuotedTypeClass(implicit ctx: Context): ClassSymbol = QuotedTypeType.symbol.asClass
 
-    lazy val QuotedType_spliceR: TypeRef = QuotedTypeClass.requiredType(tpnme.UNARY_~).typeRef
-    def QuotedType_~ : Symbol = QuotedType_spliceR.symbol
+    lazy val QuotedType_spliceR: TypeRef = QuotedTypeClass.requiredType(tpnme.splice).typeRef
+    def QuotedType_splice : Symbol = QuotedType_spliceR.symbol
 
   lazy val QuotedTypeModuleType: TermRef = ctx.requiredModuleRef("scala.quoted.Type")
   def QuotedTypeModule(implicit ctx: Context): Symbol = QuotedTypeModuleType.symbol
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index f07cb119246c..83e67d3e8c43 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -521,7 +521,7 @@ object StdNames {
     val setSymbol: N            = "setSymbol"
     val setType: N              = "setType"
     val setTypeSignature: N     = "setTypeSignature"
-    val splice: N               = "splice"
+    val splice: N               = "$splice"
     val staticClass : N         = "staticClass"
     val staticModule : N        = "staticModule"
     val staticPackage : N       = "staticPackage"
diff --git a/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala b/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala
index d226d3582735..3111ba3fadc4 100644
--- a/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala
@@ -26,7 +26,7 @@ object PickledQuotes {
   def pickleQuote(tree: Tree)(implicit ctx: Context): scala.runtime.quoted.Unpickler.Pickled = {
     if (ctx.reporter.hasErrors) Nil
     else {
-      assert(!tree.isInstanceOf[Hole]) // Should not be pickled as it represents `'(~x)` which should be optimized to `x`
+      assert(!tree.isInstanceOf[Hole]) // Should not be pickled as it represents `'{$x}` which should be optimized to `x`
       val pickled = pickle(tree)
       TastyString.pickle(pickled)
     }
diff --git a/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala b/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala
index 1d07b99ea07e..ca784d6de87f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala
@@ -122,6 +122,8 @@ abstract class CharArrayReader { self =>
   /** A new reader that takes off at the current character position */
   def lookaheadReader(): CharArrayLookaheadReader = new CharArrayLookaheadReader
 
+  def lookaheadChar(): Char = lookaheadReader().getc()
+
   class CharArrayLookaheadReader extends CharArrayReader {
     val buf: Array[Char] = self.buf
     charOffset = self.charOffset
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala b/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala
index 34c8120921f3..0c415d813889 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala
@@ -3,6 +3,7 @@ package dotc
 package parsing
 
 import core.Contexts._
+import core.Names.SimpleName
 import Scanners._
 import util.SourceFile
 import JavaTokens._
@@ -13,8 +14,10 @@ object JavaScanners {
 
   class JavaScanner(source: SourceFile, override val startFrom: Offset = 0)(implicit ctx: Context) extends ScannerCommon(source)(ctx) {
 
-    def toToken(idx: Int): Token =
+    def toToken(name: SimpleName): Token = {
+      val idx = name.start
       if (idx >= 0 && idx <= lastKeywordStart) kwArray(idx) else IDENTIFIER
+    }
 
     private class JavaTokenData0 extends TokenData
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index bdd00d714f9d..375df1eace89 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -21,6 +21,7 @@ import util.Spans._
 import Constants._
 import ScriptParsers._
 import Decorators._
+import scala.tasty.util.Chars.isIdentifierStart
 import scala.annotation.{tailrec, switch}
 import rewrites.Rewrites.patch
 
@@ -48,6 +49,13 @@ object Parsers {
     val Class, Type, TypeParam, Def: Value = Value
   }
 
+  type StageKind = Int
+  object StageKind {
+    val None = 0
+    val Quoted = 1
+    val Spliced = 2
+  }
+
   private implicit class AddDeco(val buf: ListBuffer[Tree]) extends AnyVal {
     def +++=(x: Tree) = x match {
       case x: Thicket => buf ++= x.trees
@@ -199,6 +207,16 @@ object Parsers {
     def isStatSep: Boolean =
       in.token == NEWLINE || in.token == NEWLINES || in.token == SEMI
 
+    /** A '$' identifier is treated as a splice if followed by a `{`.
+     *  A longer identifier starting with `$` is treated as a splice/id combination
+     *  in a quoted block '{...'
+     */
+    def isSplice: Boolean =
+      in.token == IDENTIFIER && in.name(0) == '$' && {
+        if (in.name.length == 1) in.lookaheadIn(BitSet(LBRACE))
+        else (staged & StageKind.Quoted) != 0
+      }
+
 /* ------------- ERROR HANDLING ------------------------------------------- */
 
     /** The offset of the last time when a statement on a new line was definitely
@@ -354,6 +372,14 @@ object Parsers {
       finally inEnum = saved
     }
 
+    private[this] var staged = StageKind.None
+    def withinStaged[T](kind: StageKind)(op: => T): T = {
+      val saved = staged
+      staged |= kind
+      try op
+      finally staged = saved
+    }
+
     def migrationWarningOrError(msg: String, offset: Int = in.offset): Unit =
       if (in.isScala2Mode)
         ctx.migrationWarning(msg, source.atSpan(Span(offset)))
@@ -677,30 +703,16 @@ object Parsers {
     def qualId(): Tree = dotSelectors(termIdent())
 
     /** SimpleExpr    ::= literal
-     *                  | symbol
+     *                  | 'id | 'this | 'true | 'false | 'null
      *                  | null
      *  @param negOffset   The offset of a preceding `-' sign, if any.
      *                     If the literal is not negated, negOffset = in.offset.
      */
     def literal(negOffset: Int = in.offset, inPattern: Boolean = false): Tree = {
-      def finish(value: Any): Tree = {
-        val t = atSpan(negOffset) { Literal(Constant(value)) }
-        in.nextToken()
-        t
-      }
-      val isNegated = negOffset < in.offset
-      atSpan(negOffset) {
-        if (in.token == SYMBOLLIT) {
-          migrationWarningOrError(em"""symbol literal '${in.name} is no longer supported,
-                                      |use a string literal "${in.name}" or an application Symbol("${in.name}") instead.""")
-          if (in.isScala2Mode) {
-            patch(source, Span(in.offset, in.offset + 1), "Symbol(\"")
-            patch(source, Span(in.charOffset - 1), "\")")
-          }
-          atSpan(in.skipToken()) { SymbolLit(in.strVal) }
-        }
-        else if (in.token == INTERPOLATIONID) interpolatedString(inPattern)
-        else finish(in.token match {
+
+      def literalOf(token: Token): Literal = {
+        val isNegated = negOffset < in.offset
+        val value = token match {
           case CHARLIT                => in.charVal
           case INTLIT                 => in.intVal(isNegated).toInt
           case LONGLIT                => in.intVal(isNegated)
@@ -713,7 +725,41 @@ object Parsers {
           case _                      =>
             syntaxErrorOrIncomplete(IllegalLiteral())
             null
-        })
+        }
+        Literal(Constant(value))
+      }
+
+      atSpan(negOffset) {
+        if (in.token == QUOTEID) {
+          if ((staged & StageKind.Spliced) != 0 && isIdentifierStart(in.name(0))) {
+            val t = atSpan(in.offset + 1) {
+              val tok = in.toToken(in.name)
+              tok match {
+                case TRUE | FALSE | NULL => literalOf(tok)
+                case THIS => This(EmptyTypeIdent)
+                case _ => Ident(in.name)
+              }
+            }
+            in.nextToken()
+            Quote(t)
+          }
+          else {
+            migrationWarningOrError(em"""symbol literal '${in.name} is no longer supported,
+                                        |use a string literal "${in.name}" or an application Symbol("${in.name}") instead,
+                                        |or enclose in braces '{${in.name}} if you want a quoted expression.""")
+            if (in.isScala2Mode) {
+              patch(source, Span(in.offset, in.offset + 1), "Symbol(\"")
+              patch(source, Span(in.charOffset - 1), "\")")
+            }
+            atSpan(in.skipToken()) { SymbolLit(in.strVal) }
+          }
+        }
+        else if (in.token == INTERPOLATIONID) interpolatedString(inPattern)
+        else {
+          val t = literalOf(in.token)
+          in.nextToken()
+          t
+        }
       }
     }
 
@@ -918,15 +964,40 @@ object Parsers {
         })
       else t
 
+    /** The block in a quote or splice */
+    def stagedBlock() =
+      inDefScopeBraces(block()) match {
+        case t @ Block(Nil, expr) if !expr.isEmpty => expr
+        case t => t
+      }
+
+    /** SimpleEpxr  ::=  spliceId | ‘$’ ‘{’ Block ‘}’)
+     *  SimpleType  ::=  spliceId | ‘$’ ‘{’ Block ‘}’)
+     */
+    def splice(isType: Boolean): Tree =
+      atSpan(in.offset) {
+        val expr =
+          if (in.name.length == 1) {
+            in.nextToken()
+            withinStaged(StageKind.Spliced)(stagedBlock())
+          }
+          else atSpan(in.offset + 1) {
+            val id = Ident(in.name.drop(1))
+            in.nextToken()
+            id
+          }
+        if (isType) TypSplice(expr) else Splice(expr)
+      }
+
     /** SimpleType       ::=  SimpleType TypeArgs
      *                     |  SimpleType `#' id
      *                     |  StableId
-     *                     |  ['~'] StableId
      *                     |  Path `.' type
      *                     |  `(' ArgTypes `)'
      *                     |  `_' TypeBounds
      *                     |  Refinement
      *                     |  Literal
+     *                     |  ‘$’ ‘{’ Block ‘}’
      */
     def simpleType(): Tree = simpleTypeRest {
       if (in.token == LPAREN)
@@ -940,8 +1011,8 @@ object Parsers {
         val start = in.skipToken()
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       }
-      else if (isIdent(nme.raw.TILDE) && in.lookaheadIn(BitSet(IDENTIFIER, BACKQUOTED_IDENT)))
-        atSpan(in.offset) { PrefixOp(typeIdent(), path(thisOK = true)) }
+      else if (isSplice)
+        splice(isType = true)
       else path(thisOK = false, handleSingletonType) match {
         case r @ SingletonTypeTree(_) => r
         case r => convertToTypeId(r)
@@ -1402,9 +1473,10 @@ object Parsers {
 
     /** SimpleExpr    ::= ‘new’ (ConstrApp [TemplateBody] | TemplateBody)
      *                 |  BlockExpr
-     *                 |  ‘'{’ BlockExprContents ‘}’
-     *                 |  ‘'(’ ExprsInParens ‘)’
-     *                 |  ‘'[’ Type ‘]’
+     *                 |  ‘'’ ‘{’ Block ‘}’
+     *                 |  ‘'’ ‘[’ Type ‘]’
+     *                 |  ‘$’ ‘{’ Block ‘}’
+     *                 |  quoteId
      *                 |  SimpleExpr1 [`_']
      *  SimpleExpr1   ::= literal
      *                 |  xmlLiteral
@@ -1419,7 +1491,10 @@ object Parsers {
       val t = in.token match {
         case XMLSTART =>
           xmlLiteral()
-        case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER =>
+        case IDENTIFIER =>
+          if (isSplice) splice(isType = false)
+          else path(thisOK = true)
+        case BACKQUOTED_IDENT | THIS | SUPER =>
           path(thisOK = true)
         case USCORE =>
           val start = in.skipToken()
@@ -1433,15 +1508,15 @@ object Parsers {
         case LBRACE =>
           canApply = false
           blockExpr()
-        case QPAREN =>
-          in.token = LPAREN
-          atSpan(in.offset)(Quote(simpleExpr()))
-        case QBRACE =>
-          in.token = LBRACE
-          atSpan(in.offset)(Quote(simpleExpr()))
-        case QBRACKET =>
-          in.token = LBRACKET
-          atSpan(in.offset)(Quote(inBrackets(typ())))
+        case QUOTE =>
+          atSpan(in.skipToken()) {
+            withinStaged(StageKind.Quoted) {
+              Quote {
+                if (in.token == LBRACKET) inBrackets(typ())
+                else stagedBlock()
+              }
+            }
+          }
         case NEW =>
           canApply = false
           newExpr()
diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
index 2ea56b46cff3..b4cf20536bb6 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -100,13 +100,12 @@ object Scanners {
     def finishNamed(idtoken: Token = IDENTIFIER, target: TokenData = this): Unit = {
       target.name = termName(flushBuf(litBuf))
       target.token = idtoken
-      if (idtoken == IDENTIFIER) {
-        val idx = target.name.start
-        target.token = toToken(idx)
-      }
+      if (idtoken == IDENTIFIER)
+        target.token = toToken(target.name)
     }
 
-    def toToken(idx: Int): Token
+    /** The token for given `name`. Either IDENTIFIER or a keyword. */
+    def toToken(name: SimpleName): Token
 
     /** Clear buffer and set string */
     def setStrVal(): Unit =
@@ -215,9 +214,11 @@ object Scanners {
       IDENTIFIER
     }
 
-    def toToken(idx: Int): Token =
+    def toToken(name: SimpleName): Token = {
+      val idx = name.start
       if (idx >= 0 && idx <= lastKeywordStart) handleMigration(kwArray(idx))
       else IDENTIFIER
+    }
 
     private class TokenData0 extends TokenData
 
@@ -520,22 +521,16 @@ object Scanners {
           def fetchSingleQuote() = {
             nextChar()
             if (isIdentifierStart(ch))
-              charLitOr { getIdentRest(); SYMBOLLIT }
+              charLitOr { getIdentRest(); QUOTEID }
             else if (isOperatorPart(ch) && (ch != '\\'))
-              charLitOr { getOperatorRest(); SYMBOLLIT }
-            else if (ch == '(' || ch == '{' || ch == '[') {
-              val tok = quote(ch)
-              charLitOr(tok)
-            }
-            else {
-              getLitChar()
-              if (ch == '\'') {
-                nextChar()
-                token = CHARLIT
-                setStrVal()
-              } else {
-                error("unclosed character literal")
-              }
+              charLitOr { getOperatorRest(); QUOTEID }
+            else ch match {
+              case '{' | '[' | ' ' | '\t' if lookaheadChar() != '\'' =>
+                token = QUOTE
+              case _ =>
+                getLitChar()
+                if (ch == '\'') finishCharLit()
+                else error("unclosed character literal")
             }
           }
           fetchSingleQuote()
@@ -965,9 +960,8 @@ object Scanners {
       }
       token = INTLIT
       if (base == 10 && ch == '.') {
-        val lookahead = lookaheadReader()
-        lookahead.nextChar()
-        if ('0' <= lookahead.ch && lookahead.ch <= '9') {
+        val lch = lookaheadChar()
+        if ('0' <= lch && lch <= '9') {
           putChar('.'); nextChar(); getFraction()
         }
       } else (ch: @switch) match {
@@ -981,30 +975,26 @@ object Scanners {
       setStrVal()
     }
 
+    private def finishCharLit(): Unit = {
+      nextChar()
+      token = CHARLIT
+      setStrVal()
+    }
+
     /** Parse character literal if current character is followed by \',
      *  or follow with given op and return a symbol literal token
      */
     def charLitOr(op: => Token): Unit = {
       putChar(ch)
       nextChar()
-      if (ch == '\'') {
-        nextChar()
-        token = CHARLIT
-        setStrVal()
-      } else {
+      if (ch == '\'') finishCharLit()
+      else {
         token = op
         strVal = if (name != null) name.toString else null
         litBuf.clear()
       }
     }
 
-    /** The opening quote bracket token corresponding to `c` */
-    def quote(c: Char): Token = c match {
-      case '(' => QPAREN
-      case '{' => QBRACE
-      case '[' => QBRACKET
-    }
-
     override def toString: String =
       showTokenDetailed(token) + {
         if ((identifierTokens contains token) || (literalTokens contains token)) " " + name
diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
index 20dcf1b7e152..7c50f77cd1fa 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -43,7 +43,7 @@ abstract class TokensCommon {
   final val STRINGLIT = 8;         enter(STRINGLIT, "string literal")
   final val STRINGPART = 9;        enter(STRINGPART, "string literal", "string literal part")
   //final val INTERPOLATIONID = 10;  enter(INTERPOLATIONID, "string interpolator")
-  //final val SYMBOLLIT = 11;        enter(SYMBOLLIT, "symbol literal") // TODO: deprecate
+  //final val QUOTEID = 11;        enter(QUOTEID, "quoted identifier") // TODO: deprecate
 
   /** identifiers */
   final val IDENTIFIER = 12;       enter(IDENTIFIER, "identifier")
@@ -149,7 +149,7 @@ object Tokens extends TokensCommon {
   final def maxToken: Int = XMLSTART
 
   final val INTERPOLATIONID = 10;  enter(INTERPOLATIONID, "string interpolator")
-  final val SYMBOLLIT = 11;        enter(SYMBOLLIT, "symbol literal") // TODO: deprecate
+  final val QUOTEID = 11;          enter(QUOTEID, "quoted identifier") // TODO: deprecate
 
   final val BACKQUOTED_IDENT = 13; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
 
@@ -193,28 +193,26 @@ object Tokens extends TokensCommon {
   final val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
   final val HASH = 82;             enter(HASH, "#")
   final val VIEWBOUND = 84;        enter(VIEWBOUND, "<%") // TODO: deprecate
-  final val QPAREN = 85;           enter(QPAREN, "'(")
-  final val QBRACE = 86;           enter(QBRACE, "'{")
-  final val QBRACKET = 87;         enter(QBRACKET, "'[")
+  final val QUOTE = 85;            enter(QUOTE, "'")
 
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
   final val alphaKeywords: TokenSet = tokenRange(IF, GIVEN)
   final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
-  final val symbolicTokens: TokenSet = tokenRange(COMMA, VIEWBOUND)
   final val keywords: TokenSet = alphaKeywords | symbolicKeywords
 
   final val allTokens: TokenSet = tokenRange(minToken, maxToken)
 
-  final val simpleLiteralTokens: TokenSet = tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, SYMBOLLIT)
+  final val simpleLiteralTokens: TokenSet =
+    tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, QUOTEID) // TODO: drop QUOTEID when symbol literals are gone
   final val literalTokens: TokenSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, NULL)
 
   final val atomicExprTokens: TokenSet = literalTokens | identifierTokens | BitSet(
-    USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, XMLSTART)
+    USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
 
   final val canStartExpressionTokens: TokenSet = atomicExprTokens | BitSet(
-    LBRACE, LPAREN, QBRACE, QPAREN, QBRACKET, IF, DO, WHILE, FOR, NEW, TRY, THROW)
+    LBRACE, LPAREN, QUOTE, IF, DO, WHILE, FOR, NEW, TRY, THROW)
 
   final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 082b737c8d81..13052d2cd8cb 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -302,6 +302,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case _ => toTextGlobal(arg)
     }
 
+    def dropBlock(tree: Tree): Tree = tree match {
+      case Block(Nil, expr) => expr
+      case _ => tree
+    }
+
     tree match {
       case id: Trees.BackquotedIdent[_] if !homogenizedView =>
         "`" ~ toText(id.name) ~ "`"
@@ -323,8 +328,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (name.isTypeName) typeText(txt)
         else txt
       case tree @ Select(qual, name) =>
-        if (tree.hasType && tree.symbol == defn.QuotedExpr_~) keywordStr("~(") ~ toTextLocal(qual) ~ keywordStr(")")
-        else if (tree.hasType && tree.symbol == defn.QuotedType_~) typeText("~(") ~ toTextLocal(qual) ~ typeText(")")
+        if (tree.hasType && tree.symbol == defn.QuotedExpr_splice) keywordStr("${") ~ toTextLocal(qual) ~ keywordStr("}")
+        else if (tree.hasType && tree.symbol == defn.QuotedType_splice) typeText("${") ~ toTextLocal(qual) ~ typeText("}")
         else if (qual.isType) toTextLocal(qual) ~ "#" ~ typeText(toText(name))
         else toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided name != nme.CONSTRUCTOR)
       case tree: This =>
@@ -572,7 +577,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           keywordStr("try ") ~ toText(expr) ~ " " ~ keywordStr("catch") ~ " {" ~ toText(handler) ~ "}" ~ optText(finalizer)(keywordStr(" finally ") ~ _)
         }
       case Quote(tree) =>
-        if (tree.isType) keywordStr("'[") ~ toTextGlobal(tree) ~ keywordStr("]") else keywordStr("'{") ~ toTextGlobal(tree) ~ keywordStr("}")
+        if (tree.isType) keywordStr("'[") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("]")
+        else keywordStr("'{") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
+      case Splice(tree) =>
+        keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case _ =>
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
index 931450af868d..70ba8e64c174 100644
--- a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
@@ -129,13 +129,13 @@ class ReifyQuotes extends MacroTransform {
 
       def mkTagSymbolAndAssignType(spliced: TermRef): TypeDef = {
         val splicedTree = tpd.ref(spliced)
-        val rhs = transform(splicedTree.select(tpnme.UNARY_~))
+        val rhs = transform(splicedTree.select(tpnme.splice))
         val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs)
         val local = ctx.newSymbol(
           owner = ctx.owner,
           name = UniqueName.fresh((splicedTree.symbol.name.toString + "$_~").toTermName).toTypeName,
           flags = Synthetic,
-          info = TypeAlias(splicedTree.tpe.select(tpnme.UNARY_~)),
+          info = TypeAlias(splicedTree.tpe.select(tpnme.splice)),
           coord = spliced.termSymbol.coord).asType
 
         ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
@@ -353,11 +353,11 @@ class ReifyQuotes extends MacroTransform {
 
           case tree: TypeTree if tree.tpe.typeSymbol.isSplice =>
             val splicedType = tree.tpe.stripTypeVar.asInstanceOf[TypeRef].prefix.termSymbol
-            transformSplice(ref(splicedType).select(tpnme.UNARY_~).withSpan(tree.span))
+            transformSplice(ref(splicedType).select(tpnme.splice).withSpan(tree.span))
 
           case tree: RefTree if isCaptured(tree.symbol, level) =>
             val t = capturers(tree.symbol).apply(tree)
-            transformSplice(t.select(if (tree.isTerm) nme.UNARY_~ else tpnme.UNARY_~))
+            transformSplice(t.select(if (tree.isTerm) nme.splice else tpnme.splice))
 
           case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>
             // Shrink size of the tree. The methods have already been inlined.
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 638abf19e613..212eef754d1d 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -29,8 +29,8 @@ import scala.reflect.ClassTag
 object Splicer {
   import tpd._
 
-  /** Splice the Tree for a Quoted expression. `~'(xyz)` becomes `xyz`
-   *  and for `~xyz` the tree of `xyz` is interpreted for which the
+  /** Splice the Tree for a Quoted expression. `${'{xyz}}` becomes `xyz`
+   *  and for `$xyz` the tree of `xyz` is interpreted for which the
    *  resulting expression is returned as a `Tree`
    *
    *  See: `Staging`
@@ -59,8 +59,8 @@ object Splicer {
       }
   }
 
-  /** Check that the Tree can be spliced. `~'(xyz)` becomes `xyz`
-    *  and for `~xyz` the tree of `xyz` is interpreted for which the
+  /** 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: `Staging`
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 103c9ad72fe8..06d1be91567e 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -30,7 +30,7 @@ import scala.annotation.constructorOnly
  *
  *  Type healing consists in transforming a phase inconsistent type `T` into `implicitly[Type[T]].unary_~`.
  *
- *  For macro definitions we assume that we have a single ~ directly as the RHS.
+ *  For macro definitions we assume that we have a single ${...} directly as the RHS.
  *  The Splicer is used to check that the RHS will be interpretable (with the `Splicer`) once inlined.
  */
 class Staging extends MacroTransform {
@@ -301,7 +301,7 @@ class Staging extends MacroTransform {
                               | The access would be accepted with the right type tag, but
                               | ${ctx.typer.missingArgMsg(tag, reqType, "")}""")
               case _ =>
-                Some(tag.select(tpnme.UNARY_~))
+                Some(tag.select(tpnme.splice))
             }
           }
         case _ =>
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index cf932dcf3c74..700d174e5671 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -162,5 +162,5 @@ class SymUtils(val self: Symbol) extends AnyVal {
 
   /** Is symbol a splice operation? */
   def isSplice(implicit ctx: Context): Boolean =
-    self == defn.QuotedExpr_~ || self == defn.QuotedType_~
+    self == defn.QuotedExpr_splice || self == defn.QuotedType_splice
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
index a7cba635b7f0..58896d9e4c4e 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
@@ -76,18 +76,24 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
             enteredSyms = enteredSyms.tail
           }
 
+      def dropEmptyBlocks(tree: Tree): Tree = tree match {
+        case Block(Nil, expr) => dropEmptyBlocks(expr)
+        case _ => tree
+      }
+
       tree match {
-        case Quoted(Spliced(t)) =>
-          transform(t) // '(~x) --> x
 
         case Quoted(quotedTree) =>
-          transformQuotation(quotedTree, tree)
-
-        case Spliced(Quoted(quotedTree)) =>
-          transform(quotedTree) // ~('x) --> x
+          dropEmptyBlocks(quotedTree) match {
+            case Spliced(t) => transform(t) // '{ $x } --> x
+            case _ => transformQuotation(quotedTree, tree)
+          }
 
-        case tree @ Spliced(_) =>
-          transformSplice(tree)
+        case tree @ Spliced(splicedTree) =>
+          dropEmptyBlocks(splicedTree) match {
+            case Quoted(t) => transform(t) // ${ 'x } --> x
+            case _ => transformSplice(tree)
+          }
 
         case Block(stats, _) =>
           val last = enteredSyms
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 0b717bd60bde..a5aca1b408d8 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -669,7 +669,7 @@ trait Implicits { self: Typer =>
             case t @ TypeRef(NoPrefix, _) =>
               inferImplicit(defn.QuotedTypeType.appliedTo(t), EmptyTree, span) match {
                 case SearchSuccess(tag, _, _) if tag.tpe.isStable =>
-                  tag.tpe.select(defn.QuotedType_~)
+                  tag.tpe.select(defn.QuotedType_splice)
                 case _ =>
                   ok = false
                   t
diff --git a/compiler/test-resources/repl/i5551 b/compiler/test-resources/repl/i5551
index 4e5a0a186a5e..eadfea38c3a6 100644
--- a/compiler/test-resources/repl/i5551
+++ b/compiler/test-resources/repl/i5551
@@ -1,9 +1,9 @@
 scala> import scala.quoted._
 
-scala> def assertImpl(expr: Expr[Boolean]) = '{ if !(~expr) then throw new AssertionError("failed assertion")}
+scala> def assertImpl(expr: Expr[Boolean]) = '{ if !($expr) then throw new AssertionError("failed assertion")}
 def assertImpl(expr: quoted.Expr[Boolean]): quoted.Expr[Unit]
 
-scala>   inline def assert(expr: => Boolean): Unit =  ~ assertImpl('(expr))
+scala>   inline def assert(expr: => Boolean): Unit =  ${ assertImpl('{expr}) }
 def assert(expr: => Boolean): Unit
 
 scala> assert(0 == 0)
diff --git a/docs/docs/internals/syntax.md b/docs/docs/internals/syntax.md
index bbdbb5bd5842..9e3bf68924c9 100644
--- a/docs/docs/internals/syntax.md
+++ b/docs/docs/internals/syntax.md
@@ -44,6 +44,7 @@ id               ::=  plainid
                    |  ‘`’ { charNoBackQuoteOrNewline | UnicodeEscape | charEscapeSeq } ‘`’
                    |  INT                           // interpolation id, only for quasi-quotes
 idrest           ::=  {letter | digit} [‘_’ op]
+quoteId          ::=  ‘'’ alphaid
 
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
 decimalNumeral   ::=  ‘0’ | nonZeroDigit {digit}
@@ -77,7 +78,7 @@ escape           ::=  ‘$$’
                    |  ‘{’ Block  [‘;’ whiteSpace stringFormat whiteSpace] ‘}’
 stringFormat     ::=  {printableChar \ (‘"’ | ‘}’ | ‘ ’ | ‘\t’ | ‘\n’)}
 
-symbolLiteral    ::=  ‘'’ plainid
+symbolLiteral    ::=  ‘'’ plainid // until 2.13
 
 comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
                    |  ‘//’ “any sequence of characters up to end of line”
@@ -153,12 +154,12 @@ AnnotType         ::=  SimpleType {Annotation}
 SimpleType        ::=  SimpleType TypeArgs                                      AppliedTypeTree(t, args)
                     |  SimpleType ‘#’ id                                        Select(t, name)
                     |  StableId
-                    |  [‘-’ | ‘+’ | ‘~’ | ‘!’] StableId                         PrefixOp(expr, op)
                     |  Path ‘.’ ‘type’                                          SingletonTypeTree(p)
                     |  ‘(’ ArgTypes ‘)’                                         Tuple(ts)
                     |  ‘_’ SubtypeBounds
                     |  Refinement                                               RefinedTypeTree(EmptyTree, refinement)
                     |  SimpleLiteral                                            SingletonTypeTree(l)
+                    |  ‘$’ ‘{’ Block ‘}’
 ArgTypes          ::=  Type {‘,’ Type}
                     |  NamedTypeArg {‘,’ NamedTypeArg}
 FunArgType        ::=  Type
@@ -208,9 +209,10 @@ InfixExpr         ::=  PrefixExpr
 PrefixExpr        ::=  [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr                       PrefixOp(expr, op)
 SimpleExpr        ::=  ‘new’ (ConstrApp [TemplateBody] | TemplateBody)          New(constr | templ)
                     |  BlockExpr
-                    |  ''{’ BlockExprContents ‘}’
-                    |  ‘'(’ ExprsInParens ‘)’
-                    |  ‘'[’ Type ‘]’
+                    |  ‘'’ ‘{’ Block ‘}’
+                    |  ‘'’ ‘[’ Type ‘]’
+                    |  ‘$’ ‘{’ Block ‘}’
+                    |  quoteId     // only inside splices
                     |  SimpleExpr1 [‘_’]                                        PostfixOp(expr, _)
 SimpleExpr1       ::=  Literal
                     |  Path
@@ -227,8 +229,7 @@ ParArgumentExprs  ::=  ‘(’ ExprsInParens ‘)’
                     |  ‘(’ [ExprsInParens] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’          exprs :+ Typed(expr, Ident(wildcardStar))
 ArgumentExprs     ::=  ParArgumentExprs
                     |  [nl] BlockExpr
-BlockExpr         ::=  ‘{’ BlockExprContents ‘}’
-BlockExprContents ::=  CaseClauses | Block
+BlockExpr         ::=  ‘{’ CaseClauses | Block ‘}’
 Block             ::=  {BlockStat semi} [BlockResult]                           Block(stats, expr?)
 BlockStat         ::=  Import
                     |  {Annotation} [‘implicit’ | ‘lazy’] Def
diff --git a/docs/docs/reference/other-new-features/principled-meta-programming.md b/docs/docs/reference/other-new-features/principled-meta-programming.md
index f382c428fc5a..7a1d2019e238 100644
--- a/docs/docs/reference/other-new-features/principled-meta-programming.md
+++ b/docs/docs/reference/other-new-features/principled-meta-programming.md
@@ -16,33 +16,33 @@ splices in exactly the same way.
 
 Principled meta programming is built on two well-known fundamental
 operations: quotation and splicing.  Quotation is expressed as
-`'(...)` or `'{...}` for expressions (both forms are equivalent) and
-as `'[...]` for types. Splicing is expressed as a prefix `~` operator.
+`'{...}` for expressions (both forms are equivalent) and
+as `'[...]` for types. Splicing is expressed as `${ ... }`.
 
 For example, the code below presents an inline function `assert`
 which calls at compile-time a method `assertImpl` with a boolean
 expression tree as argument. `assertImpl` evaluates the expression and
 prints it again in an error message if it evaluates to `false`.
-
+```scala
     import scala.quoted._
 
     inline def assert(expr: => Boolean): Unit =
-      ~ assertImpl('(expr))
+      ${ assertImpl('{ expr }) }
 
     def assertImpl(expr: Expr[Boolean]) = '{
-      if !(~expr) then
-        throw new AssertionError(s"failed assertion: ${~showExpr(expr)}")
+      if !(${ expr }) then
+        throw new AssertionError(s"failed assertion: ${${ showExpr(expr) }}")
     }
 
     def showExpr(expr: Expr[Boolean]): Expr[String] =
-      '("<some source code>") // Better implementation later in this document
-
-If `e` is an expression, then `'(e)` or `'{e}` represent the typed
+      '{ "<some source code>" } // Better implementation later in this document
+```
+If `e` is an expression, then `'{e}` represent the typed
 abstract syntax tree representing `e`. If `T` is a type, then `'[T]`
 represents the type structure representing `T`.  The precise
 definitions of "typed abstract syntax tree" or "type-structure" do not
 matter for now, the terms are used only to give some
-intuition. Conversely, `~ e` evaluates the expression `e`, which must
+intuition. Conversely, `${e}` evaluates the expression `e`, which must
 yield a typed abstract syntax tree or type structure, and embeds the
 result as an expression (respectively, type) in the enclosing program.
 
@@ -50,13 +50,18 @@ Quotations can have spliced parts in them; in this case the embedded
 splices are evaluated and embedded as part of the formation of the
 quotation.
 
+Quotes and splices can also be applied directly to identifiers. An identifier
+`$x` starting with a `$` that appears inside a quoted expression or type is treated as a
+splice `${x}`. Analogously, an quoted identifier 'x that appears inside a splice
+is treated as a quote `'{x}`. See the Syntax section below for details.
+
 Quotes and splices are duals of each other. For arbitrary
 expressions `e` and types `T` we have:
 
-    ~'(e) = e
-    '(~e) = e
-    ~'[T] = T
-    '[~T] = T
+    ${'{e}} = e
+    '{${e}} = e
+    ${'[T]} = T
+    '[${T}] = T
 
 ### Types for Quotations
 
@@ -72,16 +77,12 @@ takes expressions of type `Expr[T]` to expressions of type `T` and it
 takes expressions of type `Type[T]` to types `T`.
 
 The two types can be defined in package `scala.quoted` as follows:
-
+```scala
     package scala.quoted
 
-    sealed abstract class Expr[T] {
-      def unary_~: T   // splice operation
-    }
-    sealed abstract class Type[T] {
-      type unary_~ = T  // splice type
-    }
-
+    sealed abstract class Expr[T]
+    sealed abstract class Type[T]
+```
 Both `Expr` and `Type` are abstract and sealed, so all constructors for
 these types are provided by the system. One way to construct values of
 these types is by quoting, the other is by type-specific lifting
@@ -106,7 +107,7 @@ represented only by referring to the original variable `x`. Hence, the
 result of the program will need to persist the program state itself as
 one of its parts. We don’t want to do this, hence this situation
 should be made illegal. Dually, suppose a top-level part of a program
-is a spliced text `~{ ... x ... }` that refers to a free variable `x`
+is a spliced text `${ ... x ... }` that refers to a free variable `x`
 in `P`.  This would mean that we refer during _construction_ of `P` to
 a value that is available only during _execution_ of `P`. This is of
 course impossible and therefore needs to be ruled out.  Now, the
@@ -130,33 +131,31 @@ PCP. This is explained further in a later section.
 
 ### From `Expr`s to Functions and Back
 
-The `Expr` companion object contains an `AsFunctionN` (for 0 <= N < 23) decorator that turns a tree
+The `Expr` companion object contains an implicit `AsFunctionN` (for 0 <= N < 23) conversion that turns a tree
 describing a function into a function mapping trees to trees.
-
+```scala
     object Expr {
       ...
-      implicit class AsFunction1[T, U](f: Expr[T => U]) extends AnyVal {
-        def apply(x: Expr[T]): Expr[U] = ???
-      }
+      implied AsFunction1[T, U] for Conversion[Expr[T => U], Expr[T] => Expr[U]] ...
     }
-
+```
 This decorator gives `Expr` the `apply` operation of an applicative functor, where `Expr`s
 over function types can be applied to `Expr` arguments. The definition
 of `AsFunction1(f).apply(x)` is assumed to be functionally the same as
-`'((~f)(~x))`, however it should optimize this call by returning the
+`'{($f)($x)}`, however it should optimize this call by returning the
 result of beta-reducing `f(x)` if `f` is a known lambda expression.
 
 The `AsFunction1` decorator distributes applications of `Expr` over function
 arrows:
-
+```scala
     AsFunction1(_).apply: Expr[S => T] => (Expr[S] => Expr[T])
-
+```
 Its dual, let’s call it `reflect`, can be defined as follows:
-
+```scala
     def reflect[T, U](f: Expr[T] => Expr[U]): Expr[T => U] = '{
-      (x: T) => ~f('(x))
+      (x: T) => ${ f('x) }
     }
-
+```
 Note how the fundamental phase consistency principle works in two
 different directions here for `f` and `x`.  The reference to `f` is
 legal because it is quoted, then spliced, whereas the reference to `x`
@@ -170,28 +169,28 @@ definition of `reflect` above is not phase correct since there is a
 quote but no splice between the parameter binding of `T` and its
 usage. But the code can be made phase correct by adding a binding
 of a `Type[T]` tag:
-
-    def reflect[T, U](f: Expr[T] => Expr[U])(implicit t: Type[T]): Expr[T => U] =
-      '{ (x: ~t) => ~f('(x)) }
-
+```scala
+    def reflect[T, U](f: Expr[T] => Expr[U]) given (t: Type[T]): Expr[T => U] =
+      '{ (x: $t) => ${ f('x) } }
+```
 In this version of `reflect`, the type of `x` is now the result of
 splicing the `Type` value `t`. This operation _is_ splice correct -- there
 is one quote and one splice between the use of `t` and its definition.
 
 To avoid clutter, the Scala implementation tries to convert any phase-incorrect
-reference to a type `T` to a type-splice, by rewriting `T` to `~implicitly[Type[T]]`.
+reference to a type `T` to a type-splice, by rewriting `T` to `${ the[Type[T]] }`.
 For instance, the user-level definition of `reflect`:
-
+```scala
     def reflect[T: Type, U](f: Expr[T] => Expr[U]): Expr[T => U] =
-      '{ (x: T) => ~f('(x)) }
-
+      '{ (x: T) => ${ f('x) } }
+```
 would be rewritten to
-
+```scala
     def reflect[T: Type, U](f: Expr[T] => Expr[U]): Expr[T => U] =
-      '{ (x: ~implicitly[Type[T]]) => ~f('(x)) }
-
-The `implicitly` query succeeds because there is an implicit value of
-type `Type[T]` available (namely the evidence parameter corresponding
+      '{ (x: ${ the[Type[T]] }) => ${ f('x) } }
+```
+The `the` query succeeds because there is an implied value of
+type `Type[T]` available (namely the given parameter corresponding
 to the context bound `: Type`), and the reference to that value is
 phase-correct. If that was not the case, the phase inconsistency for
 `T` would be reported as an error.
@@ -209,16 +208,16 @@ just reifying the containing type together with the member name. But
 what to do for references to type parameters or local type definitions
 that are not defined in the current stage? Here, we cannot construct
 the `Type[T]` tree directly, so we need to get it from a recursive
-implicit search. For instance, to implemenent
-
-    implicitly[Type[List[T]]]
-
+implicit search. For instance, to implement
+```scala
+    the[Type[List[T]]]
+```
 where `T` is not defined in the current stage, we construct the type constructor
-of `List` applied to the splice of the result of searching for an implicit `Type[T]`:
-
-    '[List[~implicitly[Type[T]]]]
-
-This is in exactly the algorithm that Scala 2 uses to search for type tags.
+of `List` applied to the splice of the result of searching for an implied instance for `Type[T]`:
+```scala
+    '[ List[ ${ the[Type[T]] } ] ]
+```
+This is exactly the algorithm that Scala 2 uses to search for type tags.
 In fact Scala 2's type tag feature can be understood as a more ad-hoc version of
 `quoted.Type`. As was the case for type tags, the implicit search for a `quoted.Type`
 is handled by the compiler, using the algorithm sketched above.
@@ -226,63 +225,63 @@ is handled by the compiler, using the algorithm sketched above.
 ### Example Expansion
 
 Assume an `Array` class with an inline `map` method that forwards to a macro implementation.
-
+```scala
     class Array[T] {
-      inline def map[U](f: T => U): Array[U] = ~ Macros.mapImpl[T, U]('[U], '(this), '(f))
+      inline def map[U](f: T => U): Array[U] = ${ Macros.mapImpl[T, U]('[U], 'this, 'f) }
     }
-
+```
 Here’s the definition of the `mapImpl` macro, which takes quoted types and expressions to a quoted expression:
-
+```scala
     object Macros {
 
       def mapImpl[T, U](u: Type[U], arr: Expr[Array[T]], op: Expr[T => U]): Expr[Array[U]] = '{
         var i = 0
-        val xs = ~arr
+        val xs = $arr
         var len = xs.length
-        val ys = new Array[~u](len)
+        val ys = new Array[$u](len)
         while (i < len) {
-          ys(i) = ~op('(xs(i)))
+          ys(i) = ${ op('{ xs(i) }) }
           i += 1
         }
         ys
       }
     }
-
+```
 Here’s an application of `map` and how it rewrites to optimized code:
-
+```scala
     genSeq[Int]().map(x => x + 1)
-
+```
 ==> (inline)
-
-    val $this: Seq[Int] = genSeq[Int]()
+```scala
+    val _this: Seq[Int] = genSeq[Int]()
     val f: Int => Int = x => x + 1
-    ~ _root_.Macros.mapImpl[Int, Int]('[Int], '($this), '(f))
-
+    ${ _root_.Macros.mapImpl[Int, Int]('[Int], '_this, 'f) }
+```
 ==> (splice)
-
-    val $this: Seq[Int] = genSeq[Int]()
+```scala
+    val _this: Seq[Int] = genSeq[Int]()
     val f: Int => Int = x => x + 1
 
     {
       var i = 0
-      val xs = ~'($this)
+      val xs = ${ '_this }
       var len = xs.length
-      val ys = new Array[~'[Int]](len)
+      val ys = new Array[${ '[Int] }](len)
       while (i < len) {
-        ys(i) = ~('(f)('(xs(i))))
+        ys(i) = ${ ('f)('{ xs(i) }) }
         i += 1
       }
       ys
     }
-
+```
 ==> (expand and splice inside quotes)
-
-    val $this: Seq[Int] = genSeq[Int]()
+```scala
+    val _this: Seq[Int] = genSeq[Int]()
     val f: Int => Int = x => x + 1
 
     {
       var i = 0
-      val xs = $this
+      val xs = _this
       var len = xs.length
       val ys = new Array[Int](len)
       while (i < len) {
@@ -291,14 +290,14 @@ Here’s an application of `map` and how it rewrites to optimized code:
       }
       ys
     }
-
+```
 ==> (elim dead code)
-
-    val $this: Seq[Int] = genSeq[Int]()
+```scala
+    val _this: Seq[Int] = genSeq[Int]()
 
     {
       var i = 0
-      val xs = $this
+      val xs = _this
       var len = xs.length
       val ys = new Array[Int](len)
       while (i < len) {
@@ -307,7 +306,7 @@ Here’s an application of `map` and how it rewrites to optimized code:
       }
       ys
     }
-
+```
 ### Relationship with Inline and Macros
 
 Seen by itself, principled meta-programming looks more like a
@@ -317,31 +316,30 @@ compile-time system.  The idea is that macro elaboration can be
 understood as a combination of a macro library and a quoted
 program. For instance, here’s the `assert` macro again together with a
 program that calls `assert`.
-
+```scala
     object Macros {
 
       inline def assert(expr: => Boolean): Unit =
-        ~ assertImpl('(expr))
+        ${ assertImpl('expr) }
 
       def assertImpl(expr: Expr[Boolean]) =
-        '{ if !(~expr) then throw new AssertionError(s"failed assertion: ${~expr}") }
+        '{ if !($expr) then throw new AssertionError(s"failed assertion: ${$expr}") }
     }
 
-    // has to be in a different compilation unit that depends on Macros
     object App {
       val program = {
         val x = 1
         Macros.assert(x != 0)
       }
     }
-
+```
 Inlining the `assert` function would give the following program:
-
+```scala
     val program = {
       val x = 1
-      ~Macros.assertImpl('(x != 0))
+      ${ Macros.assertImpl('{ x != 0) } }
     }
-
+```
 The example is only phase correct because Macros is a global value and
 as such not subject to phase consistency checking. Conceptually that’s
 a bit unsatisfactory. If the PCP is so fundamental, it should be
@@ -357,12 +355,12 @@ macros would be to have the user program be in a phase after the macro
 definitions, reflecting the fact that macros have to be defined and
 compiled before they are used. Hence, conceptually the program part
 should be treated by the compiler as if it was quoted:
-
+```scala
     val program = '{
       val x = 1
-      ~Macros.assertImpl('(x != 0))
+      ${ Macros.assertImpl('{ x != 0 }) }
     }
-
+```
 If `program` is treated as a quoted expression, the call to
 `Macro.assertImpl` becomes phase correct even if macro library and
 program are conceptualized as local definitions.
@@ -382,20 +380,20 @@ either a constant or is a parameter that will be a constant when instantiated. T
 aspect is also important for macro expansion.  To illustrate this,
 consider an implementation of the `power` function that makes use of a
 statically known exponent:
-
-    inline def power(inline n: Int, x: Double) = ~powerCode(n, '(x))
+```scala
+    inline def power(inline n: Int, x: Double) = ${ powerCode(n, 'x) }
 
     private def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
-      if (n == 0) '(1.0)
+      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) }
-
-The reference to `n` as an argument in `~powerCode(n, '(x))` is not
+      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
 phase-consistent, since `n` appears in a splice without an enclosing
 quote. Normally that would be a problem because it means that we need
 the _value_ of `n` at compile time, which is not available for general
-parameters. But since `n` is a inline parameter of a macro, we know
+parameters. But since `n` is an inline parameter of a macro, we know
 that at the macro’s expansion point `n` will be instantiated to a
 constant, so the value of `n` will in fact be known at this
 point. To reflect this, we loosen the phase consistency requirements
@@ -450,24 +448,24 @@ we currently impose the following restrictions on the use of splices.
 
 The framework as discussed so far allows code to be staged, i.e. be prepared
 to be executed at a later stage. To run that code, there is another method
-in class `Expr` called `run`. Note that `~` and `run` both map from `Expr[T]`
-to `T` but only `~` is subject to the PCP, whereas `run` is just a normal method.
-
+in class `Expr` called `run`. Note that `$` and `run` both map from `Expr[T]`
+to `T` but only `$` is subject to the PCP, whereas `run` is just a normal method.
+```scala
     sealed abstract class Expr[T] {
-      def unary_~: T
-      def run(implicit runner: Runner[T]): T       // run staged code
-      def show(implicit runner: Runner[T]): String // show staged code
+      def run  given (toolbox: Toolbox): T       // run staged code
+      def show given (toolbox: Toolbox): String  // show staged code
     }
+```
 
 ### Limitations to Splicing
 
 Quotes and splices are duals as far as the PCP is concerned. But there is an additional
 restriction that needs to be imposed on splices to guarantee soundness:
 code in splices must be free of side effects. The restriction prevents code like this:
-
+```scala
      var x: Expr[T]
-     '{ (y: T) => ~{ x = '(y); 1 } }
-
+     '{ (y: T) => ${ x = 'y; 1 } }
+```
 This code, if it was accepted, would "extrude" a reference to a quoted variable `y` from its scope.
 This means we an subsequently access a variable outside the scope where it is defined, which is
 likely problematic. The code is clearly phase consistent, so we cannot use PCP to
@@ -477,14 +475,14 @@ pure by convention, and allow for undefined compiler behavior if they are not. T
 to the status of pattern guards in Scala, which are also required, but not verified, to be pure.
 
 There is also a problem with `run` in splices. Consider the following expression:
-
-    '{ (x: Int) => ~{ {'(x)}.run; 1 } }
-
+```scala
+    '{ (x: Int) => ${ ('x).run; 1 } }
+```
 This is again phase correct, but will lead us into trouble. Indeed, evaluating the splice will reduce the
-expression `{'(x)}.run` to `x`. But then the result
-
-    '{ (x: Int) => ~{ x; 1 } }
-
+expression `('x).run` to `x`. But then the result
+```scala
+    '{ (x: Int) => ${ x; 1 } }
+```
 is no longer phase correct. To prevent this soundness hole it seems easiest to classify `run` as a side-effecting
 operation. It would thus be prevented from appearing in splices. In a base language with side-effects we'd have to
 do this anyway: Since `run` runs arbitrary code it can always produce a side effect if the code it runs produces one.
@@ -493,7 +491,7 @@ do this anyway: Since `run` runs arbitrary code it can always produce a side eff
 
 Consider the following implementation of a staged interpreter that implements
 a compiler through staging.
-
+```scala
     import scala.quoted._
 
     enum Exp {
@@ -502,51 +500,53 @@ a compiler through staging.
       case Var(x: String)
       case Let(x: String, e: Exp, in: Exp)
     }
-
+```
 The interpreted language consists of numbers `Num`, addition `Plus`, and variables
 `Var` which are bound by `Let`. Here are two sample expressions in the language:
-
+```scala
     val exp = Plus(Plus(Num(2), Var("x")), Num(4))
     val letExp = Let("x", Num(3), exp)
-
+```
 Here’s a compiler that maps an expression given in the interpreted
 language to quoted Scala code of type `Expr[Int]`.
 The compiler takes an environment that maps variable names to Scala `Expr`s.
+```scala
+    import implied scala.quoted._
 
     def compile(e: Exp, env: Map[String, Expr[Int]]): Expr[Int] = e match {
       case Num(n) =>
         n.toExpr
       case Plus(e1, e2) =>
-        '(~compile(e1, env) + ~compile(e2, env))
+        '{ ${ compile(e1, env) } + ${ compile(e2, env) } }
       case Var(x) =>
         env(x)
       case Let(x, e, body) =>
-        '{ val y = ~compile(e, env); ~compile(body, env + (x -> '(y))) }
+        '{ val y = ${ compile(e, env) }; ${ compile(body, env + (x -> 'y)) } }
     }
-
+```
 Running `compile(letExp, Map())` would yield the following Scala code:
-
+```scala
     '{ val y = 3; (2 + y) + 4 }
-
+```
 The body of the first clause, `case Num(n) => n.toExpr`, looks suspicious. `n`
-is declared as an `Int`, yet it is conveted to an `Expr[Int]` with `toExpr`.
+is declared as an `Int`, yet it is converted to an `Expr[Int]` with `toExpr`.
 Shouldn’t `n` be quoted? In fact this would not
 work since replacing `n` by `'n` in the clause would not be phase
 correct.
 
-What happens instead "under the hood" is an extension method `toExpr` is added: `n.toExpr`
-is expanded to `new scala.quoted.LiftExprOps(n).toExpr`. The `toExpr` extension
-is defined in the companion object of class `Liftable` as follows:
+The `toExpr` extension method is defined in package `quoted`:
+```scala
+    package quoted
 
-    package object quoted {
-      implicit class LiftExprOps[T](val x: T) extends AnyVal {
-        def toExpr(implicit ev: Liftable[T]): Expr[T] = ev.toExpr(x)
-      }
+    implied LiftingOps {
+      def (x: T) toExpr[T] given (ev: Liftable[T]): Expr[T] = ev.toExpr(x)
     }
-
+```
 The extension says that values of types implementing the `Liftable` type class can be
-converted ("lifted") to `Expr` values using `toExpr` when `scala.quoted._` is imported.
-Dotty comes with instance definitions of `Liftable` for
+converted ("lifted") to `Expr` values using `toExpr`, provided an implied import
+of `scala.quoted._` is in scope.
+
+Dotty comes with implied instance definitions of `Liftable` for
 several types including `Boolean`, `String`, and all primitive number
 types. For example, `Int` values can be converted to `Expr[Int]`
 values by wrapping the value in a `Literal` tree node. This makes use
@@ -555,81 +555,68 @@ efficiency. But the `Liftable` instances are nevertheless not "magic"
 in the sense that they could all be defined in a user program without
 knowing anything about the representation of `Expr` trees. For
 instance, here is a possible instance of `Liftable[Boolean]`:
-
-    implicit def BooleanIsLiftable: Liftable[Boolean] = new {
-      implicit def toExpr(b: Boolean) = if (b) '(true) else '(false)
+```scala
+    implied for Liftable[Boolean] {
+      def toExpr(b: Boolean) = if (b) '{ true } else '{ false }
     }
-
+```
 Once we can lift bits, we can work our way up. For instance, here is a
 possible implementation of `Liftable[Int]` that does not use the underlying
 tree machinery:
-
-    implicit def IntIsLiftable: Liftable[Int] = new {
+```scala
+    implied for Liftable[Int] {
       def toExpr(n: Int): Expr[Int] = n match {
-        case Int.MinValue    => '(Int.MinValue)
-        case _ if n < 0      => '(-(~toExpr(n)))
-        case 0               => '(0)
-        case _ if n % 2 == 0 => '(~toExpr(n / 2) * 2)
-        case _               => '(~toExpr(n / 2) * 2 + 1)
+        case Int.MinValue    => '{ Int.MinValue }
+        case _ if n < 0      => '{ - ${ toExpr(n) } }
+        case 0               => '{ 0 }
+        case _ if n % 2 == 0 => '{ ${ toExpr(n / 2) } * 2 }
+        case _               => '{ ${ toExpr(n / 2) } * 2 + 1 }
       }
     }
-
+```
 Since `Liftable` is a type class, its instances can be conditional. For example,
 a `List` is liftable if its element type is:
-
-    implicit def ListIsLiftable[T: Liftable]: Liftable[List[T]] = new {
+```scala
+    implied [T: Liftable] for Liftable[List[T]] {
       def toExpr(xs: List[T]): Expr[List[T]] = xs match {
-        case x :: xs1 => '(~x.toExpr :: ~toExpr(xs1))
-        case Nil => '(Nil: List[T])
+        case x :: xs1 => '{ ${ toExpr(x) } :: ${ toExpr(xs1) } }
+        case Nil => '{ Nil: List[T] }
       }
     }
-
+```
 In the end, `Liftable` resembles very much a serialization
 framework. Like the latter it can be derived systematically for all
-collections, case classes and enums. Note also that the implicit synthesis
+collections, case classes and enums. Note also that the synthesis
 of "type-tag" values of type `Type[T]` is essentially the type-level
 analogue of lifting.
 
 Using lifting, we can now give the missing definition of `showExpr` in the introductory example:
-
+```scala
     def showExpr[T](expr: Expr[T]): Expr[String] = {
       val code = expr.show
       code.toExpr
     }
-
+```
 That is, the `showExpr` method converts its `Expr` argument to a string (`code`), and lifts
-the result back to an `Expr[String]` using the implicit `toExpr` conversion.
+the result back to an `Expr[String]` using the `toExpr` wrapper.
 
 ## Implementation
 
-### Syntax changes
-
-A splice `~e` on an expression of type `Expr[T]` is a normal prefix
-operator. To make it work as a type operator on `Type[T]` as well, we
-need a syntax change that introduces prefix operators as types.
-
-      SimpleType        ::=  ...
-                             [‘-’ | ‘+’ | ‘~’ | ‘!’] StableId
-
-Analogously to the situation with expressions, a prefix type operator
-such as `~ e` is treated as a shorthand for the type `e.unary_~`.
-
-Quotes are supported by introducing new tokens `'(`, `'{`, and `'[`
-and adding quoted variants `'(...)`, `'{...}` and `'[...]` to the
-`SimpleExpr` productions.
+### Syntax
 
-      SimpleExpr        ::=  ...
-                          |  ‘'{’ BlockExprContents ‘}’
-                          |  ‘'’ ‘(’ ExprsInParens ‘)’
-                          |  ‘'’ ‘[’ Type ‘]’
+Compared to the [Dotty reference grammar](../../internals/syntax.md)
+there are the following syntax changes:
 
-Syntax changes are given relative to the [Dotty reference
-grammar](../../internals/syntax.md).
+      SimpleExpr      ::=  ...
+                        |  ‘'’ ‘{’ Block ‘}’
+                        |  ‘'’ ‘[’ Type ‘]’
+                        |  ‘$’ ‘{’ Block ‘}’
+      SimpleType      ::=  ...
+                        |  ‘$’ ‘{’ Block ‘}’
 
-An alternative syntax would treat `'` as a separate operator. This
-would be attractive since it enables quoting single identifiers as
-e.g. `'x` instead of `'(x)`. But it would clash with symbol
-literals. So it could be done only if symbol literals were abolished.
+In addition, an identifier `$x` starting with a `$` that appears inside
+a quoted expression or type is treated as a splice `${x}` and a quoted identifier
+`'x` that appears inside a splice is treated as a quote `'{x}`
 
 ### Implementation in `dotc`
 
@@ -668,7 +655,7 @@ The syntax of terms, values, and types is given as follows:
                           (x: T) => t       lambda
                           t t               application
                           't                quote
-                          ~t                splice
+                          $t                splice
 
     Values        v  ::=  (x: T) => t       lambda
                           'u                quote
@@ -682,7 +669,7 @@ The syntax of terms, values, and types is given as follows:
 Typing rules are formulated using a stack of environments
 `Es`. Individual environments `E` consist as usual of variable
 bindings `x: T`. Environments can be combined using the two
-combinators `'` and `~`.
+combinators `'` and `$`.
 
     Environment   E  ::=  ()                empty
                           E, x: T
@@ -692,7 +679,7 @@ combinators `'` and `~`.
                           Es * Es           combined
 
     Separator     *  ::=  '
-                          ~
+                          $
 
 The two environment combinators are both associative with left and
 right identity `()`.
@@ -703,7 +690,7 @@ We define a small step reduction relation `-->` with the following rules:
 
                 ((x: T) => t) v  -->  [x := v]t
 
-                          ~('u)  -->  u
+                          ${'u}  -->  u
 
                              t1  -->  t2
                           -----------------
@@ -715,7 +702,7 @@ is a context rule; it says that reduction is allowed in the hole `[ ]`
 position of an evaluation context.  Evaluation contexts `e` and
 splice evaluation context `e_s` are defined syntactically as follows:
 
-    Eval context    e    ::=  [ ]  |  e t  |  v e  |  'e_s[~e]
+    Eval context    e    ::=  [ ]  |  e t  |  v e  |  'e_s[${e}]
     Splice context  e_s  ::=  [ ]  |  (x: T) => e_s  |  e_s t  |  u e_s
 
 ### Typing rules
@@ -726,12 +713,12 @@ cancel each other out:
 
                           Es1 * Es2 |- t: T
                      ---------------------------
-                     Es1 ~ E1 ' E2 * Es2 |- t: T
+                     Es1 $ E1 ' E2 * Es2 |- t: T
 
 
                           Es1 * Es2 |- t: T
                      ---------------------------
-                     Es1 ' E1 ~ E2 * Es2 |- t: T
+                     Es1 ' E1 $ E2 * Es2 |- t: T
 
 The lambda calculus fragment of the rules is standard, except that we
 use a stack of environments. The rules only interact with the topmost
@@ -751,12 +738,12 @@ environment of the stack.
                    ---------------------------------
                           Es |- t1 t2: T
 
-The rules for quotes and splices map between `expr T` and `T` by trading `'` and `~` between
+The rules for quotes and splices map between `expr T` and `T` by trading `'` and `$` between
 environments and terms.
 
-                         Es ~ () |- t: expr T
+                         Es $ () |- t: expr T
                          --------------------
-                             Es |- ~t: T
+                             Es |- $t: T
 
 
                            Es ' () |- t: T
@@ -777,10 +764,10 @@ pattern matching. This opens new possibilities. For instance, here is a
 version of `power` that generates the multiplications directly if the
 exponent is statically known and falls back to the dynamic
 implementation of power otherwise.
-
-    inline def power(n: Int, x: Double): Double = ~{
-      '(n) match {
-        case Constant(n1) => powerCode(n1, '(x))
+```scala
+    inline def power(n: Int, x: Double): Double = ${
+      'n match {
+        case Constant(n1) => powerCode(n1, 'x)
         case _ => '{ dynamicPower(n, x) }
       }
     }
@@ -789,35 +776,36 @@ implementation of power otherwise.
       if (n == 0) 1.0
       else if (n % 2 == 0) dynamicPower(n / 2, x * x)
       else x * dynamicPower(n - 1, x)
-
+```
 This assumes a `Constant` extractor that maps tree nodes representing
 constants to their values.
 
-With the right extractors the "AsFunction" operation
+With the right extractors, the "AsFunction" conversion
 that maps expressions over functions to functions over expressions can
 be implemented in user code:
-
-    implicit class AsFunction[T, U](f: Expr[T => U]) extends AnyVal {
-      def apply(x: Expr[T]): Expr[U] =
-        f match {
-          case Lambda(g) => g(x)
-          case _ => '((~f)(~x))
-        }
-
+```scala
+    implied AsFunction1[T, U] for Conversion[Expr[T => U], Expr[T] => Expr[U]] {
+      def apply(f: Expr[T => U]): Expr[T] => Expr[U] =
+       (x: Expr[T]) => f match {
+         case Lambda(g) => g(x)
+         case _ => '{ ($f)($x) }
+       }
+    }
+```
 This assumes an extractor
-
+```scala
     object Lambda {
       def unapply[T, U](x: Expr[T => U]): Option[Expr[T] => Expr[U]]
     }
-
+```
 Once we allow inspection of code via extractors, it’s tempting to also
 add constructors that create typed trees directly without going
 through quotes. Most likely, those constructors would work over `Expr`
 types which lack a known type argument. For instance, an `Apply`
 constructor could be typed as follows:
-
+```scala
     def Apply(fn: Expr[_], args: List[Expr[_]]): Expr[_]
-
+```
 This would allow constructing applications from lists of arguments
 without having to match the arguments one-by-one with the
 corresponding formal parameter types of the function. We then need "at
diff --git a/docs/docs/reference/other-new-features/tasty-reflect.md b/docs/docs/reference/other-new-features/tasty-reflect.md
index 1f85e824199f..a98010a52991 100644
--- a/docs/docs/reference/other-new-features/tasty-reflect.md
+++ b/docs/docs/reference/other-new-features/tasty-reflect.md
@@ -24,7 +24,7 @@ To provide reflection capabilities in macros we need to add an implicit paramete
 import scala.quoted._
 import scala.tasty._
 
-inline def natConst(x: Int): Int = ~natConstImpl('(x))
+inline def natConst(x: Int): Int = ~natConstImpl('x)
 
 def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
   import reflection._
diff --git a/library/src-bootstrapped/scala/StagedTuple.scala b/library/src-bootstrapped/scala/StagedTuple.scala
index b64d39794b0a..ff65b01770f1 100644
--- a/library/src-bootstrapped/scala/StagedTuple.scala
+++ b/library/src-bootstrapped/scala/StagedTuple.scala
@@ -9,56 +9,56 @@ object StagedTuple {
   private final val specialize = true
 
   def toArrayStaged(tup: Expr[Tuple], size: Option[Int]): Expr[Array[Object]] = {
-    if (!specialize) '(dynamicToArray(~tup))
+    if (!specialize) '{dynamicToArray($tup)}
     else size match {
       case Some(0) =>
-        '($emptyArray)
+        '{empty$Array}
       case Some(1) =>
-        tup.as[Tuple1[Object]].bind(t => '(Array((~t)._1)))
+        tup.as[Tuple1[Object]].bind(t => '{Array($t._1)})
       case Some(2) =>
-        tup.as[Tuple2[Object, Object]].bind(t => '(Array((~t)._1, (~t)._2)))
+        tup.as[Tuple2[Object, Object]].bind(t => '{Array($t._1, $t._2)})
       case Some(3) =>
-        tup.as[Tuple3[Object, Object, Object]].bind(t => '(Array((~t)._1, (~t)._2, (~t)._3)))
+        tup.as[Tuple3[Object, Object, Object]].bind(t => '{Array($t._1, $t._2, $t._3)})
       case Some(4) =>
-        tup.as[Tuple4[Object, Object, Object, Object]].bind(t => '(Array((~t)._1, (~t)._2, (~t)._3, (~t)._4)))
-      case Some(n) if n <= $MaxSpecialized =>
-        '($toArray(~tup, ~n.toExpr))
+        tup.as[Tuple4[Object, Object, Object, Object]].bind(t => '{Array($t._1, $t._2, $t._3, $t._4)})
+      case Some(n) if n <= MaxSpecialized =>
+        '{to$Array($tup, ${ n.toExpr })}
       case Some(n) =>
-        '((~tup.as[TupleXXL]).elems)
+        '{${ tup.as[TupleXXL] }.elems}
       case None =>
-        '(dynamicToArray(~tup))
+        '{dynamicToArray($tup)}
     }
   }
 
   def fromArrayStaged[T <: Tuple : Type](xs: Expr[Array[Object]], size: Option[Int]): Expr[T] = {
-    if (!specialize) '(dynamicFromArray[T](~xs))
+    if (!specialize) '{dynamicFromArray[T]($xs)}
     else xs.bind { xs =>
       val tup: Expr[Any] = size match {
-        case Some(0)  => '()
-        case Some(1)  => '(Tuple1( (~xs)(0)))
-        case Some(2)  => '(Tuple2( (~xs)(0), (~xs)(1)))
-        case Some(3)  => '(Tuple3( (~xs)(0), (~xs)(1), (~xs)(2)))
-        case Some(4)  => '(Tuple4( (~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3)))
-        case Some(5)  => '(Tuple5( (~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4)))
-        case Some(6)  => '(Tuple6( (~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5)))
-        case Some(7)  => '(Tuple7( (~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6)))
-        case Some(8)  => '(Tuple8( (~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7)))
-        case Some(9)  => '(Tuple9( (~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8)))
-        case Some(10) => '(Tuple10((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9)))
-        case Some(11) => '(Tuple11((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10)))
-        case Some(12) => '(Tuple12((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11)))
-        case Some(13) => '(Tuple13((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12)))
-        case Some(14) => '(Tuple14((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13)))
-        case Some(15) => '(Tuple15((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14)))
-        case Some(16) => '(Tuple16((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15)))
-        case Some(17) => '(Tuple17((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15), (~xs)(16)))
-        case Some(18) => '(Tuple18((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15), (~xs)(16), (~xs)(17)))
-        case Some(19) => '(Tuple19((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15), (~xs)(16), (~xs)(17), (~xs)(18)))
-        case Some(20) => '(Tuple20((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15), (~xs)(16), (~xs)(17), (~xs)(18), (~xs)(19)))
-        case Some(21) => '(Tuple21((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15), (~xs)(16), (~xs)(17), (~xs)(18), (~xs)(19), (~xs)(20)))
-        case Some(22) => '(Tuple22((~xs)(0), (~xs)(1), (~xs)(2), (~xs)(3), (~xs)(4), (~xs)(5), (~xs)(6), (~xs)(7), (~xs)(8), (~xs)(9), (~xs)(10), (~xs)(11), (~xs)(12), (~xs)(13), (~xs)(14), (~xs)(15), (~xs)(16), (~xs)(17), (~xs)(18), (~xs)(19), (~xs)(20), (~xs)(21)))
-        case Some(_)  => '(TupleXXL(~xs))
-        case None     => '(dynamicFromArray[T](~xs))
+        case Some(0)  => '{}
+        case Some(1)  => '{Tuple1( $xs(0))}
+        case Some(2)  => '{Tuple2( $xs(0), $xs(1))}
+        case Some(3)  => '{Tuple3( $xs(0), $xs(1), $xs(2))}
+        case Some(4)  => '{Tuple4( $xs(0), $xs(1), $xs(2), $xs(3))}
+        case Some(5)  => '{Tuple5( $xs(0), $xs(1), $xs(2), $xs(3), $xs(4))}
+        case Some(6)  => '{Tuple6( $xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5))}
+        case Some(7)  => '{Tuple7( $xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6))}
+        case Some(8)  => '{Tuple8( $xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7))}
+        case Some(9)  => '{Tuple9( $xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8))}
+        case Some(10) => '{Tuple10($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9))}
+        case Some(11) => '{Tuple11($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10))}
+        case Some(12) => '{Tuple12($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11))}
+        case Some(13) => '{Tuple13($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12))}
+        case Some(14) => '{Tuple14($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13))}
+        case Some(15) => '{Tuple15($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14))}
+        case Some(16) => '{Tuple16($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15))}
+        case Some(17) => '{Tuple17($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15), $xs(16))}
+        case Some(18) => '{Tuple18($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15), $xs(16), $xs(17))}
+        case Some(19) => '{Tuple19($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15), $xs(16), $xs(17), $xs(18))}
+        case Some(20) => '{Tuple20($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15), $xs(16), $xs(17), $xs(18), $xs(19))}
+        case Some(21) => '{Tuple21($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15), $xs(16), $xs(17), $xs(18), $xs(19), $xs(20))}
+        case Some(22) => '{Tuple22($xs(0), $xs(1), $xs(2), $xs(3), $xs(4), $xs(5), $xs(6), $xs(7), $xs(8), $xs(9), $xs(10), $xs(11), $xs(12), $xs(13), $xs(14), $xs(15), $xs(16), $xs(17), $xs(18), $xs(19), $xs(20), $xs(21))}
+        case Some(_)  => '{TupleXXL($xs)}
+        case None     => '{dynamicFromArray[T]($xs)}
       }
       tup.as[T]
     }
@@ -66,109 +66,109 @@ object StagedTuple {
 
   def sizeStaged[Res <: Int : Type](tup: Expr[Tuple], size: Option[Int]): Expr[Res] = {
     val res =
-      if (!specialize) '(dynamicSize(~tup))
+      if (!specialize) '{dynamicSize($tup)}
       else size match {
         case Some(n) => n.toExpr
-        case None => '(dynamicSize(~tup))
+        case None => '{dynamicSize($tup)}
       }
     res.as[Res]
   }
 
   def headStaged[Tup <: NonEmptyTuple : Type](tup: Expr[Tup], size: Option[Int]): Expr[Head[Tup]] = {
-    if (!specialize) '(dynamicHead(~tup))
+    if (!specialize) '{dynamicHead($tup)}
     else {
       val resVal = size match {
         case Some(1) =>
-          '((~tup.as[Tuple1[_]])._1)
+          '{${ tup.as[Tuple1[_]] }._1}
         case Some(2) =>
-          '((~tup.as[Tuple2[_, _]])._1)
+          '{${ tup.as[Tuple2[_, _]] }._1}
         case Some(3) =>
-          '((~tup.as[Tuple3[_, _, _]])._1)
+          '{${ tup.as[Tuple3[_, _, _]]}._1}
         case Some(4) =>
-          '((~tup.as[Tuple4[_, _, _, _]])._1)
-        case Some(n) if n > 4 && n <= $MaxSpecialized =>
-          '((~tup.as[Product]).productElement(0))
-        case Some(n) if n > $MaxSpecialized =>
-          '((~tup.as[TupleXXL]).elems(0))
+          '{${ tup.as[Tuple4[_, _, _, _]] }._1}
+        case Some(n) if n > 4 && n <= MaxSpecialized =>
+          '{${ tup.as[Product] }.productElement(0)}
+        case Some(n) if n > MaxSpecialized =>
+          '{${tup.as[TupleXXL] }.elems(0)}
         case None =>
-          '(dynamicHead(~tup))
+          '{dynamicHead($tup)}
       }
       resVal.as[Head[Tup]]
     }
   }
 
   def tailStaged[Tup <: NonEmptyTuple : Type](tup: Expr[Tup], size: Option[Int]): Expr[Tail[Tup]] = {
-    if (!specialize) '(dynamicTail[Tup](~tup))
+    if (!specialize) '{dynamicTail[Tup]($tup)}
     else {
       val res = size match {
         case Some(1) =>
-          '()
+          '{}
         case Some(2) =>
-          tup.as[Tuple2[_, _]].bind(t => '(Tuple1((~t)._2)))
+          tup.as[Tuple2[_, _]].bind(t => '{Tuple1($t._2)})
         case Some(3) =>
-          tup.as[Tuple3[_, _, _]].bind(t => '(Tuple2((~t)._2, (~t)._3)))
+          tup.as[Tuple3[_, _, _]].bind(t => '{Tuple2($t._2, $t._3)})
         case Some(4) =>
-          tup.as[Tuple4[_, _, _, _]].bind(t => '(Tuple3((~t)._2, (~t)._3, (~t)._4)))
+          tup.as[Tuple4[_, _, _, _]].bind(t => '{Tuple3($t._2, $t._3, $t._4)})
         case Some(5) =>
-          tup.as[Tuple5[_, _, _, _, _]].bind(t => '(Tuple4((~t)._2, (~t)._3, (~t)._4, (~t)._5)))
+          tup.as[Tuple5[_, _, _, _, _]].bind(t => '{Tuple4($t._2, $t._3, $t._4, $t._5)})
         case Some(n) if n > 5 =>
           val arr = toArrayStaged(tup, size)
-          fromArrayStaged('((~arr).tail) , Some(n - 1))
+          fromArrayStaged('{ $arr.tail }, Some(n - 1))
         case None =>
-          '(dynamicTail(~tup))
+          '{dynamicTail($tup)}
       }
       res.as[Tail[Tup]]
     }
   }
 
   def applyStaged[Tup <: NonEmptyTuple : Type, N <: Int : Type](tup: Expr[Tup], size: Option[Int], n: Expr[N], nValue: Option[Int]): Expr[Elem[Tup, N]] = {
-    if (!specialize) '(dynamicApply(~tup, ~n))
+    if (!specialize) '{dynamicApply($tup, $n)}
     else {
       def fallbackApply(): Expr[Elem[Tup, N]] = nValue match {
         case Some(n) => quoted.QuoteError("index out of bounds: " + n)
-        case None => '(dynamicApply(~tup, ~n))
+        case None => '{dynamicApply($tup, $n)}
       }
       val res = size match {
         case Some(1) =>
           val t = tup.as[Tuple1[_]]
           nValue match {
-            case Some(0) => '((~t)._1)
+            case Some(0) => '{$t._1}
             case _ => fallbackApply()
           }
         case Some(2) =>
           val t = tup.as[Tuple2[_, _]]
           nValue match {
-            case Some(0) => '((~t)._1)
-            case Some(1) => '((~t)._2)
+            case Some(0) => '{$t._1}
+            case Some(1) => '{$t._2}
             case _ => fallbackApply()
           }
         case Some(3) =>
           val t = tup.as[Tuple3[_, _, _]]
           nValue match {
-            case Some(0) => '((~t)._1)
-            case Some(1) => '((~t)._2)
-            case Some(2) => '((~t)._3)
+            case Some(0) => '{$t._1}
+            case Some(1) => '{$t._2}
+            case Some(2) => '{$t._3}
             case _ => fallbackApply()
           }
         case Some(4) =>
           val t = tup.as[Tuple4[_, _, _, _]]
           nValue match {
-            case Some(0) => '((~t)._1)
-            case Some(1) => '((~t)._2)
-            case Some(2) => '((~t)._3)
-            case Some(3) => '((~t)._4)
+            case Some(0) => '{$t._1}
+            case Some(1) => '{$t._2}
+            case Some(2) => '{$t._3}
+            case Some(3) => '{$t._4}
             case _ => fallbackApply()
           }
-        case Some(s) if s > 4 && s <= $MaxSpecialized =>
+        case Some(s) if s > 4 && s <= MaxSpecialized =>
           val t = tup.as[Product]
           nValue match {
-            case Some(n) if n >= 0 && n < s => '((~t).productElement(~n.toExpr))
+            case Some(n) if n >= 0 && n < s => '{$t.productElement(${ n.toExpr })}
             case _ => fallbackApply()
           }
-        case Some(s) if s > $MaxSpecialized =>
+        case Some(s) if s > MaxSpecialized =>
           val t = tup.as[TupleXXL]
           nValue match {
-            case Some(n) if n >= 0 && n < s => '((~t).elems(~n.toExpr))
+            case Some(n) if n >= 0 && n < s => '{$t.elems(${ n.toExpr })}
             case _ => fallbackApply()
           }
         case _ => fallbackApply()
@@ -178,50 +178,50 @@ object StagedTuple {
   }
 
   def stagedCons[T <: Tuple & Singleton : Type, H : Type](self: Expr[T], x: Expr[H], tailSize: Option[Int]): Expr[H *: T] =
-  if (!specialize) '(dynamic_*:[T, H](~self, ~x))
+  if (!specialize) '{dynamic_*:[T, H]($self, $x)}
   else {
     val res = tailSize match {
       case Some(0) =>
-        '(Tuple1(~x))
+        '{Tuple1($x)}
       case Some(1) =>
-        self.as[Tuple1[_]].bind(t => '(Tuple2(~x, (~t)._1)))
+        self.as[Tuple1[_]].bind(t => '{Tuple2($x, $t._1)})
       case Some(2) =>
-        self.as[Tuple2[_, _]].bind(t => '(Tuple3(~x, (~t)._1, (~t)._2)))
+        self.as[Tuple2[_, _]].bind(t => '{Tuple3($x, $t._1, $t._2)})
       case Some(3) =>
-        self.as[Tuple3[_, _, _]].bind(t => '(Tuple4(~x, (~t)._1, (~t)._2, (~t)._3)))
+        self.as[Tuple3[_, _, _]].bind(t => '{Tuple4($x, $t._1, $t._2, $t._3)})
       case Some(4) =>
-        self.as[Tuple4[_, _, _, _]].bind(t => '(Tuple5(~x, (~t)._1, (~t)._2, (~t)._3, (~t)._4)))
+        self.as[Tuple4[_, _, _, _]].bind(t => '{Tuple5($x, $t._1, $t._2, $t._3, $t._4)})
       case Some(n) =>
-        fromArrayStaged[H *: T]('($consArray(~x, ~toArrayStaged(self, tailSize))), Some(n + 1))
+        fromArrayStaged[H *: T]('{cons$Array($x, ${ toArrayStaged(self, tailSize) })}, Some(n + 1))
       case _ =>
-        '(dynamic_*:[T, H](~self, ~x))
+        '{dynamic_*:[T, H]($self, $x)}
     }
     res.as[H *: T]
   }
 
   def stagedConcat[Self <: Tuple & Singleton : Type, That <: Tuple & Singleton : Type](self: Expr[Self], selfSize: Option[Int], that: Expr[That], thatSize: Option[Int]): Expr[Concat[Self, That]] = {
-    if (!specialize) '(dynamic_++[Self, That](~self, ~that))
+    if (!specialize) '{dynamic_++[Self, That]($self, $that)}
     else {
       def genericConcat(xs: Expr[Tuple], ys: Expr[Tuple]): Expr[Tuple] =
-        fromArrayStaged[Tuple]('((~toArrayStaged(xs, None)) ++ (~toArrayStaged(ys, None))), None)
+        fromArrayStaged[Tuple]('{${ toArrayStaged(xs, None) } ++ ${ toArrayStaged(ys, None) }}, None)
 
       val res = selfSize match {
         case Some(0) =>
           that
         case Some(1) =>
           if (thatSize.contains(0)) self
-          else stagedCons(that, '((~self).asInstanceOf[Tuple1[_]]._1), thatSize)
+          else stagedCons(that, '{$self.asInstanceOf[Tuple1[_]]._1}, thatSize)
         case Some(2) =>
           val self2 = self.as[Tuple2[_, _]]
           thatSize match {
             case Some(0) => self
             case Some(1) =>
               self2.bind { t =>
-                that.as[Tuple1[_]].bind(u => '(Tuple3((~t)._1, (~t)._2, (~u)._1)))
+                that.as[Tuple1[_]].bind(u => '{Tuple3($t._1, $t._2, $u._1)})
               }
             case Some(2) =>
               self2.bind { t =>
-                that.as[Tuple2[_, _]].bind(u => '(Tuple4((~t)._1, (~t)._2, (~u)._1, (~u)._2)))
+                that.as[Tuple2[_, _]].bind(u => '{Tuple4($t._1, $t._2, $u._1, $u._2)})
               }
             case _ =>
               genericConcat(self, that)
@@ -232,7 +232,7 @@ object StagedTuple {
             case Some(0) => self
             case Some(1) =>
               self2.bind { t =>
-                that.as[Tuple1[_]].bind(u => '(Tuple4((~t)._1, (~t)._2, (~t)._3, (~u)._1)))
+                that.as[Tuple1[_]].bind(u => '{Tuple4($t._1, $t._2, $t._3, $u._1)})
               }
             case _ =>
               genericConcat(self, that)
@@ -241,7 +241,7 @@ object StagedTuple {
           if (thatSize.contains(0)) self
           else genericConcat(self, that)
         case None =>
-          '(dynamic_++(~self, ~that))
+          '{dynamic_++($self, $that)}
       }
       res.as[Concat[Self, That]]
     }
@@ -249,11 +249,11 @@ object StagedTuple {
 
   private implicit class ExprOps[U: Type](expr: Expr[U]) {
 
-    def as[T: Type]: Expr[T] = '{ (~expr).asInstanceOf[T] }
+    def as[T: Type]: Expr[T] = '{ $expr.asInstanceOf[T] }
 
     def bind[T: Type](in: Expr[U] => Expr[T]): Expr[T] = '{
-      val t: U = (~expr)
-      ~(in('(t)))
+      val t: U = $expr
+      ${in('t)}
     }
 
   }
diff --git a/library/src-bootstrapped/scala/Tuple.scala b/library/src-bootstrapped/scala/Tuple.scala
index 07b524050612..03b067d22949 100644
--- a/library/src-bootstrapped/scala/Tuple.scala
+++ b/library/src-bootstrapped/scala/Tuple.scala
@@ -10,7 +10,7 @@ sealed trait Tuple extends Any {
     if (stageIt) stagedToArray
     else inline constValueOpt[BoundedSize[this.type]] match {
       case Some(0) =>
-        $emptyArray
+        empty$Array
       case Some(1) =>
         val t = asInstanceOf[Tuple1[Object]]
         Array(t._1)
@@ -23,8 +23,8 @@ sealed trait Tuple extends Any {
       case Some(4) =>
         val t = asInstanceOf[Tuple4[Object, Object, Object, Object]]
         Array(t._1, t._2, t._3, t._4)
-      case Some(n) if n <= $MaxSpecialized =>
-        $toArray(this, n)
+      case Some(n) if n <= MaxSpecialized =>
+        to$Array(this, n)
       case Some(n) =>
         asInstanceOf[TupleXXL].elems
       case None =>
@@ -32,7 +32,7 @@ sealed trait Tuple extends Any {
     }
 
   inline def stagedToArray: Array[Object] =
-    ~StagedTuple.toArrayStaged('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.toArrayStaged('this, constValueOpt[BoundedSize[this.type]]) }
 
   inline def *: [H] (x: H): H *: this.type =
     if (stageIt) stagedCons[H](x)
@@ -53,14 +53,14 @@ sealed trait Tuple extends Any {
           val t = asInstanceOf[Tuple4[_, _, _, _]]
           Tuple5(x, t._1, t._2, t._3, t._4).asInstanceOf[Result]
         case Some(n) =>
-          fromArray[Result]($consArray(x, toArray))
+          fromArray[Result](cons$Array(x, toArray))
         case _ =>
           dynamic_*:[this.type, H](this, x)
       }
     }
 
   inline def stagedCons[H] (x: H): H *: this.type =
-    ~StagedTuple.stagedCons('(this), '(x), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.stagedCons('this, 'x, constValueOpt[BoundedSize[this.type]]) }
 
   inline def ++(that: Tuple): Concat[this.type, that.type] =
     if (stageIt) stagedConcat(that)
@@ -104,8 +104,8 @@ sealed trait Tuple extends Any {
     }
 
   inline def stagedConcat(that: Tuple): Concat[this.type, that.type] =
-    ~StagedTuple.stagedConcat('(this), constValueOpt[BoundedSize[this.type]],
-                              '(that), constValueOpt[BoundedSize[that.type]])
+    ${ StagedTuple.stagedConcat('this, constValueOpt[BoundedSize[this.type]],
+                                'that, constValueOpt[BoundedSize[that.type]]) }
 
   inline def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
     fromArray[T](xs.toArray ++ ys.toArray)
@@ -121,12 +121,12 @@ sealed trait Tuple extends Any {
     }
 
   inline def stagedSize: Size[this.type] =
-    ~StagedTuple.sizeStaged[Size[this.type]]('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.sizeStaged[Size[this.type]]('this, constValueOpt[BoundedSize[this.type]]) }
 }
 
 object Tuple {
-  inline val $MaxSpecialized = 22
-  inline private val XXL = $MaxSpecialized + 1
+  inline val MaxSpecialized = 22
+  inline private val XXL = MaxSpecialized + 1
 
   final val stageIt = false
 
@@ -167,9 +167,9 @@ object Tuple {
 
   private[scala] type BoundedSize[X] = BoundedSizeRecur[X, 23]
 
-  val $emptyArray = Array[Object]()
+  val empty$Array = Array[Object]()
 
-  def $toArray(xs: Tuple, n: Int) = {
+  def to$Array(xs: Tuple, n: Int) = {
     val arr = new Array[Object](n)
     var i = 0
     var it = xs.asInstanceOf[Product].productIterator
@@ -180,7 +180,7 @@ object Tuple {
     arr
   }
 
-  def $consArray[H](x: H, elems: Array[Object]): Array[Object] = {
+  def cons$Array[H](x: H, elems: Array[Object]): Array[Object] = {
     val elems1 = new Array[Object](elems.length + 1)
     elems1(0) = x.asInstanceOf[Object]
     System.arraycopy(elems, 0, elems1, 1, elems.length)
@@ -217,7 +217,7 @@ object Tuple {
     }
 
   inline def stagedFromArray[T <: Tuple](xs: Array[Object]): T =
-    ~StagedTuple.fromArrayStaged[T]('(xs), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.fromArrayStaged[T]('xs, constValueOpt[BoundedSize[this.type]]) }
 
   def dynamicFromArray[T <: Tuple](xs: Array[Object]): T = xs.length match {
     case 0  => ().asInstanceOf[T]
@@ -248,7 +248,7 @@ object Tuple {
 
   def dynamicToArray(self: Tuple): Array[Object] = (self: Any) match {
     case self: Unit =>
-      $emptyArray
+      empty$Array
     case self: Tuple1[_] =>
       val t = self.asInstanceOf[Tuple1[Object]]
       Array(t._1)
@@ -283,7 +283,7 @@ object Tuple {
       case self: Tuple4[_, _, _, _] =>
         Tuple5(x, self._1, self._2, self._3, self._4).asInstanceOf[Result]
       case _ =>
-        dynamicFromArray[Result]($consArray(x, dynamicToArray(self)))
+        dynamicFromArray[Result](cons$Array(x, dynamicToArray(self)))
     }
   }
 
@@ -328,9 +328,9 @@ sealed trait NonEmptyTuple extends Tuple {
         case Some(4) =>
           val t = asInstanceOf[Tuple4[_, _, _, _]]
           t._1
-        case Some(n) if n > 4 && n <= $MaxSpecialized =>
+        case Some(n) if n > 4 && n <= MaxSpecialized =>
           asInstanceOf[Product].productElement(0)
-        case Some(n) if n > $MaxSpecialized =>
+        case Some(n) if n > MaxSpecialized =>
           val t = asInstanceOf[TupleXXL]
           t.elems(0)
         case None =>
@@ -340,7 +340,7 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def stagedHead: Head[this.type] =
-    ~StagedTuple.headStaged[this.type]('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.headStaged[this.type]('this, constValueOpt[BoundedSize[this.type]]) }
 
   inline def tail: Tail[this.type] =
     if (stageIt) stagedTail
@@ -369,7 +369,7 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def stagedTail: Tail[this.type] =
-    ~StagedTuple.tailStaged[this.type]('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.tailStaged[this.type]('this, constValueOpt[BoundedSize[this.type]]) }
 
   inline def fallbackApply(n: Int) =
     inline constValueOpt[n.type] match {
@@ -412,13 +412,13 @@ sealed trait NonEmptyTuple extends Tuple {
             case Some(3) => t._4.asInstanceOf[Result]
             case _ => fallbackApply(n).asInstanceOf[Result]
           }
-        case Some(s) if s > 4 && s <= $MaxSpecialized =>
+        case Some(s) if s > 4 && s <= MaxSpecialized =>
           val t = asInstanceOf[Product]
           inline constValueOpt[n.type] match {
             case Some(n) if n >= 0 && n < s => t.productElement(n).asInstanceOf[Result]
             case _ => fallbackApply(n).asInstanceOf[Result]
           }
-        case Some(s) if s > $MaxSpecialized =>
+        case Some(s) if s > MaxSpecialized =>
           val t = asInstanceOf[TupleXXL]
           inline constValueOpt[n.type] match {
             case Some(n) if n >= 0 && n < s => t.elems(n).asInstanceOf[Result]
@@ -429,9 +429,9 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def stagedApply(n: Int): Elem[this.type, n.type] =
-    ~StagedTuple.applyStaged[this.type, n.type](
-      '(this), constValueOpt[Size[this.type]],
-      '(n), constValueOpt[n.type])
+    ${ StagedTuple.applyStaged[this.type, n.type](
+       'this, constValueOpt[Size[this.type]],
+       'n, constValueOpt[n.type]) }
 }
 
 object NonEmptyTuple {
diff --git a/library/src-bootstrapped/scala/quoted/package.scala b/library/src-bootstrapped/scala/quoted/package.scala
index f7ece4905368..54ef75f46823 100644
--- a/library/src-bootstrapped/scala/quoted/package.scala
+++ b/library/src-bootstrapped/scala/quoted/package.scala
@@ -9,8 +9,8 @@ package object quoted {
   implicit class ListOfExprOps[T](val list: List[Expr[T]]) extends AnyVal {
     def toExprOfList(implicit ev: Type[T]): Expr[List[T]] = {
       def rec(list: List[Expr[T]]): Expr[List[T]] = list match {
-        case x :: xs  => '{ (~x) :: (~rec(xs)) }
-        case Nil => '(Nil)
+        case x :: xs  => '{ ($x) :: ${rec(xs)} }
+        case Nil => '{Nil}
       }
       rec(list)
     }
diff --git a/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala b/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
index ccc2bf6a3a82..3bc96e6e0e2f 100644
--- a/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
+++ b/library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala
@@ -14,12 +14,13 @@ trait TreeUtils {
     implicit val rhsTpe: quoted.Type[T] = rhs.tpe.seal.asInstanceOf[quoted.Type[T]]
     val rhsExpr = rhs.seal[T]
     val expr = '{
-      val x = ~rhsExpr
-      ~{
-        val id = ('(x)).unseal.asInstanceOf[Term.Ident]
+      val x = $rhsExpr
+      ${
+        val id = ('x).unseal.asInstanceOf[Term.Ident]
         body(id).seal[Any]
       }
     }
     expr.unseal
   }
+
 }
diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala
index eda1fb984802..b61ac8bc6814 100644
--- a/library/src/scala/quoted/Expr.scala
+++ b/library/src/scala/quoted/Expr.scala
@@ -3,7 +3,8 @@ package scala.quoted
 import scala.runtime.quoted.Unpickler.Pickled
 
 sealed abstract class Expr[+T] {
-  final def unary_~ : T = throw new Error("~ should have been compiled away")
+
+  final def `$splice`: T = throw new Error("splice should have been compiled away")
 
   /** Evaluate the contents of this expression and return the result.
    *
@@ -13,6 +14,7 @@ sealed abstract class Expr[+T] {
 
   /** Show a source code like representation of this expression */
   final def show(implicit toolbox: Toolbox): String = toolbox.show(this)
+
 }
 
 object Expr {
@@ -146,7 +148,7 @@ object Exprs {
   // TODO Use a List in FunctionAppliedTo(val f: Expr[_], val args: List[Expr[_]])
   // FIXME: Having the List in the code above trigers an assertion error while testing dotty.tools.dotc.reporting.ErrorMessagesTests.i3187
   //        This test does redefine `scala.collection`. Further investigation is needed.
-  /** An Expr representing `'{(~f).apply(~x1, ..., ~xn)}` but it is beta-reduced when the closure is known */
+  /** An Expr representing `'{($f).apply($x1, ..., $xn)}` but it is beta-reduced when the closure is known */
   final class FunctionAppliedTo[+R](val f: Expr[_], val args: Array[Expr[_]]) extends Expr[R] {
     override def toString: String = s"Expr($f <applied to> ${args.toList})"
   }
diff --git a/library/src/scala/quoted/Liftable.scala b/library/src/scala/quoted/Liftable.scala
index 871fde9ee6c0..e56e3bc594d8 100644
--- a/library/src/scala/quoted/Liftable.scala
+++ b/library/src/scala/quoted/Liftable.scala
@@ -3,7 +3,7 @@ package scala.quoted
 import scala.runtime.quoted.Unpickler.liftedExpr
 
 /** A typeclass for types that can be turned to `quoted.Expr[T]`
- *  without going through an explicit `'(...)` operation.
+ *  without going through an explicit `'{...}` operation.
  */
 abstract class Liftable[T] {
   def toExpr(x: T): Expr[T]
diff --git a/library/src/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala
index 9eeed775ad69..487b90ce4f8d 100644
--- a/library/src/scala/quoted/Type.scala
+++ b/library/src/scala/quoted/Type.scala
@@ -5,7 +5,7 @@ import scala.reflect.ClassTag
 import scala.runtime.quoted.Unpickler.Pickled
 
 sealed abstract class Type[T] {
-  type unary_~ = T
+  type `$splice` = T
 }
 
 /** Some basic type tags, currently incomplete */
diff --git a/tests/disabled/run/i4803d/App_2.scala b/tests/disabled/run/i4803d/App_2.scala
index deb7b1151384..4b55e7e49634 100644
--- a/tests/disabled/run/i4803d/App_2.scala
+++ b/tests/disabled/run/i4803d/App_2.scala
@@ -11,7 +11,7 @@ object Test {
   }
 
   inline def power2(x: Double) = {
-    inline def power(x: Double, inline n: Long) = ~PowerMacro.powerCode('(x), n)
+    inline def power(x: Double, inline n: Long) = ${ PowerMacro.powerCode('x, n) }
     power(x, 2)
   }
 }
diff --git a/tests/disabled/run/i4803d/Macro_1.scala b/tests/disabled/run/i4803d/Macro_1.scala
index 681f3b2fac63..8070c3180721 100644
--- a/tests/disabled/run/i4803d/Macro_1.scala
+++ b/tests/disabled/run/i4803d/Macro_1.scala
@@ -2,7 +2,7 @@ import scala.quoted._
 
 object PowerMacro {
   def powerCode(x: Expr[Double], n: Long): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode('(y), n / 2) }
-    else '{ ~x * ~powerCode(x, n - 1) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ val y = $x * $x; ${powerCode('y, n / 2)} }
+    else '{ $x * ${powerCode(x, n - 1)} }
 }
diff --git a/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala b/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala
index f99da7d01204..4a6c7f2c80b2 100644
--- a/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala
+++ b/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala
@@ -9,11 +9,11 @@ object XmlQuote {
 
   implicit object SCOps {
     inline def xml(this inline ctx: StringContext)(args: => Any*): Xml =
-      ~XmlQuote.impl(ctx, '(args))
+      ${XmlQuote.impl(ctx, 'args)}
   }
 
   def impl(receiver: StringContext, args: Expr[Seq[Any]]): Expr[Xml] = {
     val string = receiver.parts.mkString("??")
-    '(new Xml(~string.toExpr, (~args).toList))
+    '{new Xml(${string.toExpr}, ($args).toList)}
   }
 }
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 a9daf7d26556..883c2de12f44 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,7 +3,7 @@ import scala.quoted._
 import scala.quoted.Toolbox.Default._
 
 object Macros {
-  inline def foo(i: => Int): Int = ~fooImpl('(i))
+  inline 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 a9daf7d26556..883c2de12f44 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,7 +3,7 @@ import scala.quoted._
 import scala.quoted.Toolbox.Default._
 
 object Macros {
-  inline def foo(i: => Int): Int = ~fooImpl('(i))
+  inline 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/i4044a.scala b/tests/neg/i4044a.scala
index daa64fce9fac..29ec5b53e00e 100644
--- a/tests/neg/i4044a.scala
+++ b/tests/neg/i4044a.scala
@@ -2,12 +2,12 @@ import scala.quoted._
 
 class Test {
 
-  val a = '(1)
+  val a = '{1}
   '{
     a // error
-    ~a
-    '(~a) // error
-    '( '(~a) ) // error
+    $a
+    '{$a} // error
+    '{ '{$a} } // error
   }
 
 }
diff --git a/tests/neg/i4044b.scala b/tests/neg/i4044b.scala
index cc44b6fd8a1e..191039ed9f18 100644
--- a/tests/neg/i4044b.scala
+++ b/tests/neg/i4044b.scala
@@ -4,13 +4,13 @@ class Test {
 
   '{
 
-    val b = '(3)
+    val b = '{3}
 
     '{
       b // error
-      ~(b)
-      ~('(b)) // error
-      '( '(~b) ) // error
+      ${b}
+      ${ '{b} } // error
+      '{ '{$b} } // error
     }
 
   }
diff --git a/tests/neg/i4350.scala b/tests/neg/i4350.scala
index 968a293424b2..fb40aca02715 100644
--- a/tests/neg/i4350.scala
+++ b/tests/neg/i4350.scala
@@ -1,5 +1,5 @@
 import scala.quoted.Type
 
 class Foo[T] {
-  '(null.asInstanceOf[T]) // error
+  '{null.asInstanceOf[T]} // error
 }
diff --git a/tests/neg/i4433.scala b/tests/neg/i4433.scala
index 1c7eb18d9785..7da5fadcc7ad 100644
--- a/tests/neg/i4433.scala
+++ b/tests/neg/i4433.scala
@@ -1,7 +1,7 @@
 
 object Foo {
-  inline def g(inline p: Int => Boolean): Boolean = ~{ // error
-    if(p(5)) '(true)
-    else '(false)
+  inline def g(inline p: Int => Boolean): Boolean = ${ // error
+    if(p(5)) 'true
+    else 'false
   }
 }
diff --git a/tests/neg/i4493-b.scala b/tests/neg/i4493-b.scala
index 0eab22187f22..aae0ba99230a 100644
--- a/tests/neg/i4493-b.scala
+++ b/tests/neg/i4493-b.scala
@@ -1,7 +1,7 @@
 class Index[K]
 object Index {
-  inline def succ[K](x: K): Unit = ~{ // error
+  inline def succ[K](x: K): Unit = ${ // error
     implicit val t: quoted.Type[K] = '[K]
-    '(new Index[K])
+    '{new Index[K]}
   }
 }
diff --git a/tests/neg/i4493.scala b/tests/neg/i4493.scala
index 929d13c9e45e..74efc5c99a8a 100644
--- a/tests/neg/i4493.scala
+++ b/tests/neg/i4493.scala
@@ -1,7 +1,7 @@
 class Index[K]
 object Index {
-  inline def succ[K]: Unit = ~{ // error
+  inline def succ[K]: Unit = ${ // error
     implicit val t: quoted.Type[K] = '[K]
-    '(new Index[K])
+    '{new Index[K]}
   }
 }
diff --git a/tests/neg/i4774b.scala b/tests/neg/i4774b.scala
index 517aa02f9823..1f9c16cb1bd5 100644
--- a/tests/neg/i4774b.scala
+++ b/tests/neg/i4774b.scala
@@ -3,9 +3,9 @@ import scala.quoted._
 
 object Test {
   def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{
-    val y: ~t = ~x;
-    ~loop[~t]( // error
-      '(y)
-    )
+    val y: $t = $x;
+    ${loop[$t]( // error
+      'y
+    )}
   }
 }
diff --git a/tests/neg/i4890.scala b/tests/neg/i4890.scala
index 2e44839b03ad..d809c54e3a5f 100644
--- a/tests/neg/i4890.scala
+++ b/tests/neg/i4890.scala
@@ -3,6 +3,6 @@ import scala.quoted._
 object Test {
   def toExpr(x: Option[String]): Expr[String] = x match {
     case Some(s) =>
-      '(s)  // error
+      's  // error
   }
 }
diff --git a/tests/neg/i5954.scala b/tests/neg/i5954.scala
index e20b33850bdf..73af3b84b2bd 100644
--- a/tests/neg/i5954.scala
+++ b/tests/neg/i5954.scala
@@ -6,5 +6,5 @@ object MatcherFactory1 {
   import scala.quoted._
 
   def impl2(a: MatcherFactory1)(self: Expr[a.AndNotWord]) =
-  '{ ~self } // error: access to value a from wrong staging level
+    '{ val a: Any = $self } // error: access to value a from wrong staging level
 }
diff --git a/tests/neg/inline-case-objects/Main_2.scala b/tests/neg/inline-case-objects/Main_2.scala
index a61b0fc060dc..95488814cadf 100644
--- a/tests/neg/inline-case-objects/Main_2.scala
+++ b/tests/neg/inline-case-objects/Main_2.scala
@@ -6,6 +6,6 @@ object Test {
     println(fooString(bar.Baz)) // error
   }
 
-  inline def fooString(inline x: Any): String = ~Macros.impl(x)
+  inline def fooString(inline x: Any): String = ${ Macros.impl(x) }
 
 }
diff --git a/tests/neg/inline-macro-staged-interpreter/Macro_1.scala b/tests/neg/inline-macro-staged-interpreter/Macro_1.scala
index 3e67577a3874..56a6c16402cf 100644
--- a/tests/neg/inline-macro-staged-interpreter/Macro_1.scala
+++ b/tests/neg/inline-macro-staged-interpreter/Macro_1.scala
@@ -3,7 +3,7 @@ import scala.quoted._
 
 object E {
 
-  inline def eval[T](inline x: E[T]): T = ~impl(x)
+  inline def eval[T](inline x: E[T]): T = ${ impl(x) }
 
   def impl[T](x: E[T]): Expr[T] = x.lift
 
@@ -28,6 +28,6 @@ trait Op2[T] {
 trait Plus2[T] extends Op2[T]
 object Plus2 {
   implicit case object IPlus extends Plus2[Int] {
-    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '(~x + ~y)
+    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '{$x + $y}
   }
 }
diff --git a/tests/neg/inline-option/Macro_1.scala b/tests/neg/inline-option/Macro_1.scala
index e78b1987f58c..280adb79224c 100644
--- a/tests/neg/inline-option/Macro_1.scala
+++ b/tests/neg/inline-option/Macro_1.scala
@@ -4,6 +4,6 @@ import scala.quoted._
 object Macro {
   def impl(opt: Option[Int]): Expr[Int] = opt match {
     case Some(i) => i.toExpr
-    case None => '(-1)
+    case None => '{-1}
   }
 }
\ No newline at end of file
diff --git a/tests/neg/inline-option/Main_2.scala b/tests/neg/inline-option/Main_2.scala
index 7ae506282eba..37425a3b4aa3 100644
--- a/tests/neg/inline-option/Main_2.scala
+++ b/tests/neg/inline-option/Main_2.scala
@@ -6,10 +6,10 @@ object Main {
   val b: Option[Int] = Some(4)
   size(b) // error
 
-  inline def size(inline opt: Option[Int]): Int = ~Macro.impl(opt)
+  inline def size(inline opt: Option[Int]): Int = ${ Macro.impl(opt) }
 
-  inline def size2(inline i: Int): Int = ~Macro.impl(None)
+  inline def size2(inline i: Int): Int = ${ Macro.impl(None) }
 
-  inline def size3(inline i: Int): Int = ~Macro.impl(Some(i))
+  inline def size3(inline i: Int): Int = ${ Macro.impl(Some(i)) }
   
 }
\ No newline at end of file
diff --git a/tests/neg/inline-tuples-1/Main_2.scala b/tests/neg/inline-tuples-1/Main_2.scala
index 199c0fbdcbb6..16d7916c55a1 100644
--- a/tests/neg/inline-tuples-1/Main_2.scala
+++ b/tests/neg/inline-tuples-1/Main_2.scala
@@ -347,27 +347,27 @@ object Test {
     )))
   }
 
-  inline def sum(inline tup: Tuple1[Int]): Int = ~Macros.tup1(tup)
-  inline def sum(inline tup: Tuple2[Int, Int]): Int = ~Macros.tup2(tup)
-  inline def sum(inline tup: Tuple3[Int, Int, Int]): Int = ~Macros.tup3(tup)
-  inline def sum(inline tup: Tuple4[Int, Int, Int, Int]): Int = ~Macros.tup4(tup)
-  inline def sum(inline tup: Tuple5[Int, Int, Int, Int, Int]): Int = ~Macros.tup5(tup)
-  inline def sum(inline tup: Tuple6[Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup6(tup)
-  inline def sum(inline tup: Tuple7[Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup7(tup)
-  inline def sum(inline tup: Tuple8[Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup8(tup)
-  inline def sum(inline tup: Tuple9[Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup9(tup)
-  inline def sum(inline tup: Tuple10[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup10(tup)
-  inline def sum(inline tup: Tuple11[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup11(tup)
-  inline def sum(inline tup: Tuple12[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup12(tup)
-  inline def sum(inline tup: Tuple13[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup13(tup)
-  inline def sum(inline tup: Tuple14[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup14(tup)
-  inline def sum(inline tup: Tuple15[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup15(tup)
-  inline def sum(inline tup: Tuple16[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup16(tup)
-  inline def sum(inline tup: Tuple17[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup17(tup)
-  inline def sum(inline tup: Tuple18[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup18(tup)
-  inline def sum(inline tup: Tuple19[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup19(tup)
-  inline def sum(inline tup: Tuple20[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup20(tup)
-  inline def sum(inline tup: Tuple21[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup21(tup)
-  inline def sum(inline tup: Tuple22[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup22(tup)
+  inline def sum(inline tup: Tuple1[Int]): Int = ${ Macros.tup1(tup) }
+  inline def sum(inline tup: Tuple2[Int, Int]): Int = ${ Macros.tup2(tup) }
+  inline def sum(inline tup: Tuple3[Int, Int, Int]): Int = ${ Macros.tup3(tup) }
+  inline def sum(inline tup: Tuple4[Int, Int, Int, Int]): Int = ${ Macros.tup4(tup) }
+  inline def sum(inline tup: Tuple5[Int, Int, Int, Int, Int]): Int = ${ Macros.tup5(tup) }
+  inline def sum(inline tup: Tuple6[Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup6(tup) }
+  inline def sum(inline tup: Tuple7[Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup7(tup) }
+  inline def sum(inline tup: Tuple8[Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup8(tup) }
+  inline def sum(inline tup: Tuple9[Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup9(tup) }
+  inline def sum(inline tup: Tuple10[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup10(tup) }
+  inline def sum(inline tup: Tuple11[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup11(tup) }
+  inline def sum(inline tup: Tuple12[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup12(tup) }
+  inline def sum(inline tup: Tuple13[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup13(tup) }
+  inline def sum(inline tup: Tuple14[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup14(tup) }
+  inline def sum(inline tup: Tuple15[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup15(tup) }
+  inline def sum(inline tup: Tuple16[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup16(tup) }
+  inline def sum(inline tup: Tuple17[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup17(tup) }
+  inline def sum(inline tup: Tuple18[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup18(tup) }
+  inline def sum(inline tup: Tuple19[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup19(tup) }
+  inline def sum(inline tup: Tuple20[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup20(tup) }
+  inline def sum(inline tup: Tuple21[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup21(tup) }
+  inline def sum(inline tup: Tuple22[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup22(tup) }
 
 }
diff --git a/tests/neg/quote-0.scala b/tests/neg/quote-0.scala
index e6eae3dfe802..5f4299d10682 100644
--- a/tests/neg/quote-0.scala
+++ b/tests/neg/quote-0.scala
@@ -4,22 +4,22 @@ class Test {
 
   val x: Int = 0
 
-  '{ '(x + 1)  // error: wrong staging level
+  '{ '{x + 1}  // error: wrong staging level
 
-    '((y: Expr[Int]) => ~y )  // error: wrong staging level
+    '{(y: Expr[Int]) => $y }  // error: wrong staging level
 
   }
 
-  '(x + 1)  // error: wrong staging level
+  '{x + 1}  // error: wrong staging level
 
-  '((y: Expr[Int]) => ~y )  // error: wrong staging level
+  '{(y: Expr[Int]) => $y }  // error: wrong staging level
 
   def f[T](t: Type[T], x: Expr[T]) = '{
-    val z2 = ~x // error // error: wrong staging level
+    val z2 = $x // error // error: wrong staging level
   }
 
   def g[T](implicit t: Type[T], x: Expr[T]) = '{
-    val z2 = ~x   // ok
+    val z2 = $x   // ok
   }
 
 }
diff --git a/tests/neg/quote-MacroOverride.scala b/tests/neg/quote-MacroOverride.scala
index cfc0a7ebb374..55e03eee5381 100644
--- a/tests/neg/quote-MacroOverride.scala
+++ b/tests/neg/quote-MacroOverride.scala
@@ -6,7 +6,7 @@ object Test {
   }
 
   object B extends A {
-    inline def f() = ~('())  // error: may not override
+    inline def f() = ${'{}}  // error: may not override
     override def g() = ()    // error: may not override
   }
 
diff --git a/tests/neg/quote-complex-top-splice.scala b/tests/neg/quote-complex-top-splice.scala
index 6b0c57a2e51f..f0b5b74513b5 100644
--- a/tests/neg/quote-complex-top-splice.scala
+++ b/tests/neg/quote-complex-top-splice.scala
@@ -4,26 +4,26 @@ import scala.quoted._
 
 object Test {
 
-  inline def foo1: Unit = ~{ // error
+  inline def foo1: Unit = ${ // error
     val x = 1
     impl(x)
   }
 
-  inline def foo2: Unit = ~impl({ // error
+  inline def foo2: Unit = ${ impl({ // error
     val x = 1
     x
-  })
+  }) }
 
-  inline def foo3: Unit = ~impl({ // error
+  inline def foo3: Unit = ${ impl({ // error
     println("foo3")
     3
-  })
+  }) }
 
-  inline def foo4: Unit = ~{ // error
+  inline def foo4: Unit = ${ // error
     println("foo4")
     impl(1)
   }
 
-  def impl(i: Int): Expr[Unit] = '()
+  def impl(i: Int): Expr[Unit] = '{}
 
 }
diff --git a/tests/neg/quote-error-2/Macro_1.scala b/tests/neg/quote-error-2/Macro_1.scala
index 0cce8284f871..f6507f10e49c 100644
--- a/tests/neg/quote-error-2/Macro_1.scala
+++ b/tests/neg/quote-error-2/Macro_1.scala
@@ -1,12 +1,12 @@
 import quoted._
 
 object Macro_1 {
-  inline def foo(inline b: Boolean): Unit = ~fooImpl(b)
+  inline def foo(inline b: Boolean): Unit = ${ fooImpl(b) }
   def fooImpl(b: Boolean): Expr[Unit] =
-    '(println(~msg(b)))
+    '{println(${msg(b)})}
 
   def msg(b: Boolean): Expr[String] =
-    if (b) '("foo(true)")
+    if (b) '{"foo(true)"}
     else QuoteError("foo cannot be called with false")
 
 }
diff --git a/tests/neg/quote-error/Macro_1.scala b/tests/neg/quote-error/Macro_1.scala
index d6fbeb9a9ed9..5713a4e3ec2e 100644
--- a/tests/neg/quote-error/Macro_1.scala
+++ b/tests/neg/quote-error/Macro_1.scala
@@ -1,8 +1,8 @@
 import quoted._
 
 object Macro_1 {
-  inline def foo(inline b: Boolean): Unit = ~fooImpl(b)
+  inline def foo(inline b: Boolean): Unit = ${fooImpl(b)}
   def fooImpl(b: Boolean): Expr[Unit] =
-    if (b) '(println("foo(true)"))
+    if (b) '{println("foo(true)")}
     else QuoteError("foo cannot be called with false")
 }
diff --git a/tests/neg/quote-exception/Macro_1.scala b/tests/neg/quote-exception/Macro_1.scala
index cd477085e822..721b9d1d97cf 100644
--- a/tests/neg/quote-exception/Macro_1.scala
+++ b/tests/neg/quote-exception/Macro_1.scala
@@ -1,8 +1,8 @@
 import quoted._
 
 object Macro_1 {
-  inline def foo(inline b: Boolean): Unit = ~fooImpl(b)
+  inline def foo(inline b: Boolean): Unit = ${fooImpl(b)}
   def fooImpl(b: Boolean): Expr[Unit] =
-    if (b) '(println("foo(true)"))
+    if (b) '{println("foo(true)")}
     else ???
 }
diff --git a/tests/neg/quote-interpolator-core-old.scala b/tests/neg/quote-interpolator-core-old.scala
index 43eeef3ff95f..d01fc5bc6587 100644
--- a/tests/neg/quote-interpolator-core-old.scala
+++ b/tests/neg/quote-interpolator-core-old.scala
@@ -5,21 +5,21 @@ import scala.quoted._
 object FInterpolation {
 
   implicit class FInterpolatorHelper(val sc: StringContext) extends AnyVal {
-    inline def ff(arg1: Any): String = ~fInterpolation(sc, Seq('(arg1))) // error: Inline macro method must be a static method
-    inline def ff(arg1: Any, arg2: Any): String = ~fInterpolation(sc, Seq('(arg1), '(arg2))) // error: Inline macro method must be a static method
-    inline def ff(arg1: Any, arg2: Any, arg3: Any): String = ~fInterpolation(sc, Seq('(arg1), '(arg2), '(arg3))) // error: Inline macro method must be a static method
+    inline def ff(arg1: Any): String = ${fInterpolation(sc, Seq('arg1))} // error: Inline macro method must be a static method
+    inline def ff(arg1: Any, arg2: Any): String = ${fInterpolation(sc, Seq('arg1, 'arg2))} // error: Inline macro method must be a static method
+    inline def ff(arg1: Any, arg2: Any, arg3: Any): String = ${fInterpolation(sc, Seq('arg1, 'arg2, 'arg3))} // error: Inline macro method must be a static method
     // ...
   }
 
   private def liftSeq(args: Seq[Expr[Any]]): Expr[Seq[Any]] = args match {
-    case x :: xs  => '{ (~x) +: ~(liftSeq(xs))  }
-    case Nil => '(Seq(): Seq[Any])
+    case x :: xs  => '{ ($x) +: ${liftSeq(xs)}  }
+    case Nil => '{Seq(): Seq[Any]}
   }
 
   def fInterpolation(sc: StringContext, args: Seq[Expr[Any]]): Expr[String] = {
     val str: Expr[String] = sc.parts.mkString("").toExpr
     val args1: Expr[Seq[Any]] = liftSeq(args)
-    '{  (~str).format(~args1: _*) }
+    '{ $str.format($args1: _*) }
   }
 
   def hello = "hello"
diff --git a/tests/neg/quote-macro-2-splices.scala b/tests/neg/quote-macro-2-splices.scala
index 30667b3e35d8..7b85b6f51255 100644
--- a/tests/neg/quote-macro-2-splices.scala
+++ b/tests/neg/quote-macro-2-splices.scala
@@ -3,9 +3,9 @@ import scala.quoted._
 object Macro {
 
   inline def foo(b: Boolean): Int = { // error
-    if (b) ~bar(true)
-    else ~bar(false)
+    if (b) ${ bar(true) }
+    else ${ bar(false) }
   }
 
-  def bar(b: Boolean): Expr[Int] = if (b) '(1) else '(0)
+  def bar(b: Boolean): Expr[Int] = if (b) '{1} else '{0}
 }
diff --git a/tests/neg/quote-macro-complex-arg-0.scala b/tests/neg/quote-macro-complex-arg-0.scala
index 7afe76ae0fd9..90e202b21a31 100644
--- a/tests/neg/quote-macro-complex-arg-0.scala
+++ b/tests/neg/quote-macro-complex-arg-0.scala
@@ -1,6 +1,6 @@
 import scala.quoted._
 
 object Macros {
-  inline def foo(inline 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 }
+  inline def foo(inline 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-macro-splice.scala b/tests/neg/quote-macro-splice.scala
index e854a76a77f7..9125f56159ad 100644
--- a/tests/neg/quote-macro-splice.scala
+++ b/tests/neg/quote-macro-splice.scala
@@ -4,21 +4,21 @@ object Test {
 
   inline def foo1: Int = { // error
     println()
-    ~impl(1.toExpr)
+    ${ impl(1.toExpr) }
   }
 
   inline def foo2: Int = { // error
-    ~impl(1.toExpr)
-    ~impl(2.toExpr)
+    ${ impl(1.toExpr) }
+    ${ impl(2.toExpr) }
   }
 
   inline def foo3: Int = { // error
     val a = 1
-    ~impl('(a))
+    ${ impl('a) }
   }
 
   inline def foo4: Int = { // error
-    ~impl('(1))
+    ${ impl('{1}) }
     1
   }
 
diff --git a/tests/neg/quote-pcp-in-arg.scala b/tests/neg/quote-pcp-in-arg.scala
index c4c49b06b00c..d864e84272c1 100644
--- a/tests/neg/quote-pcp-in-arg.scala
+++ b/tests/neg/quote-pcp-in-arg.scala
@@ -1,6 +1,6 @@
 import scala.quoted._
 
 object Foo {
-  inline def foo(x: Int): Int = ~bar('{ '(x); x }) // error
+  inline def foo(x: Int): Int = ${ bar('{ 'x; x }) } // error
   def bar(i: Expr[Int]): Expr[Int] = i
 }
diff --git a/tests/neg/quote-splice-interpret-1.scala b/tests/neg/quote-splice-interpret-1.scala
index 2113ad9f6c2d..dacd3886f9fd 100644
--- a/tests/neg/quote-splice-interpret-1.scala
+++ b/tests/neg/quote-splice-interpret-1.scala
@@ -2,8 +2,8 @@
 import scala.quoted._
 
 object Macros {
-  inline def isZero(inline n: Int): Boolean = ~{ // error
-    if (n == 0) '(true)
-    else '(false)
+  inline def isZero(inline n: Int): Boolean = ${ // error
+    if (n == 0) 'true
+    else 'false
   }
 }
diff --git a/tests/neg/quote-spliceNonStaged.scala b/tests/neg/quote-spliceNonStaged.scala
index b328aabac7b9..fe93e73a2bf2 100644
--- a/tests/neg/quote-spliceNonStaged.scala
+++ b/tests/neg/quote-spliceNonStaged.scala
@@ -3,5 +3,5 @@ import scala.quoted._
 
 object Quotes_1 {
   def printHello: Expr[Unit] = '{ println("Hello") }
-  ~printHello // error
+  $printHello // error
 }
diff --git a/tests/neg/quote-this.scala b/tests/neg/quote-this.scala
index b9b2d0034ea3..ddfc6961661c 100644
--- a/tests/neg/quote-this.scala
+++ b/tests/neg/quote-this.scala
@@ -11,19 +11,19 @@ class Foo {
     }
   }
 
-  inline def i(): Unit = ~Foo.impl[Any]('{
-    '(this) // error
-  })
+  inline def i(): Unit = ${ Foo.impl[Any]('{
+    'this // error
+  }) }
 
-  inline def j(that: Foo): Unit = ~Foo.impl[Any]('{
-    '(that) // error
-  })
+  inline def j(that: Foo): Unit = ${ Foo.impl[Any]('{
+    'that // error
+  }) }
 
-  inline def k(): Unit = ~Foo.impl[Any](this) // error
-  inline def l(that: Foo): Unit = ~Foo.impl[Any](that) // error
+  inline def k(): Unit = ${ Foo.impl[Any](this) } // error
+  inline def l(that: Foo): Unit = ${ Foo.impl[Any](that) } // error
 
 }
 
 object Foo {
-  def impl[T](x: Any): Expr[Unit] = '()
+  def impl[T](x: Any): Expr[Unit] = '{}
 }
diff --git a/tests/neg/splice-in-top-level-splice-1.scala b/tests/neg/splice-in-top-level-splice-1.scala
index 6f7f80514561..921007e2d292 100644
--- a/tests/neg/splice-in-top-level-splice-1.scala
+++ b/tests/neg/splice-in-top-level-splice-1.scala
@@ -1,7 +1,7 @@
 import scala.quoted._
 
 object Foo {
-  inline def foo(): Int = ~bar(~x) // error
-  def x: Expr[Int] = '(1)
+  inline def foo(): Int = ${bar($x)} // error
+  def x: Expr[Int] = '{1}
   def bar(i: Int): Expr[Int] = i.toExpr
 }
diff --git a/tests/neg/splice-in-top-level-splice-2.scala b/tests/neg/splice-in-top-level-splice-2.scala
index 85e60baae56e..58efc998f66a 100644
--- a/tests/neg/splice-in-top-level-splice-2.scala
+++ b/tests/neg/splice-in-top-level-splice-2.scala
@@ -1,6 +1,6 @@
 import scala.quoted._
 
 object Foo {
-  inline def foo(): Int = ~(~x) // error
-  def x: Expr[Expr[Int]] = '( '(1) )
+  inline def foo(): Int = ${$x} // error
+  def x: Expr[Expr[Int]] = '{ '{1} }
 }
diff --git a/tests/neg/splice-non-expr.scala b/tests/neg/splice-non-expr.scala
new file mode 100644
index 000000000000..d0236fd6a2a4
--- /dev/null
+++ b/tests/neg/splice-non-expr.scala
@@ -0,0 +1,11 @@
+class Foo {
+  '{
+    ${3} // error
+    ${new Object} // error
+    ${"abc"} // error
+    ${()} // error
+    ${new Foo} // error
+  }
+
+  def unary_~ : Int = 9
+}
diff --git a/tests/neg/tasty-macro-assert/quoted_1.scala b/tests/neg/tasty-macro-assert/quoted_1.scala
index aff13eaf145c..801219e3e78b 100644
--- a/tests/neg/tasty-macro-assert/quoted_1.scala
+++ b/tests/neg/tasty-macro-assert/quoted_1.scala
@@ -12,7 +12,7 @@ object Asserts {
   object Ops
 
   inline def macroAssert(cond: => Boolean): Unit =
-    ~impl('(cond))
+    ${impl('cond)}
 
   def impl(cond: Expr[Boolean])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -34,9 +34,9 @@ object Asserts {
 
     tree match {
       case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
-        '(assertTrue(~left.seal[Boolean])) // Buggy code. To generate the errors
+        '{assertTrue(${left.seal[Boolean]})} // Buggy code. To generate the errors
       case _ =>
-        '(assertTrue(~cond))
+        '{assertTrue($cond)}
     }
 
   }
diff --git a/tests/pending/run/patmat-exprs.scala b/tests/pending/run/patmat-exprs.scala
index 7ca5fd30633f..78e1811169bc 100644
--- a/tests/pending/run/patmat-exprs.scala
+++ b/tests/pending/run/patmat-exprs.scala
@@ -430,8 +430,8 @@ trait Pattern {
   case class Div[T](left: Expr[T], right: Expr[T])
                                  (implicit num: NumericOps[T]) extends TwoArg[T] {
 
-    // [f(x) / g(x)]' = [f(x) * 1 / g(x)]' = f'(x) * 1 / g(x) + f(x) * [1 / g(x)]' =
-    //    f'(x) / g(x) + f(x) * [-1 / g(x) ^ 2] * g'(x) = (f'(x) * g(x) - f(x) * g'(x)) / g(x)^2
+    // [f(x) / g(x)]' = [f(x) * 1 / g(x)]' = f'{x} * 1 / g(x) + f(x) * [1 / g(x)]' =
+    //    f'{x} / g(x) + f(x) * [-1 / g(x) ^ 2] * g'{x} = (f'{x} * g(x) - f(x) * g'{x}) / g(x)^2
     def derivative(v: Var[T]) =
       Div(
         Sub(
@@ -449,7 +449,7 @@ trait Pattern {
 
   case class Inv[T](expr: Expr[T])(implicit num: NumericOps[T]) extends OneArg[T] {
 
-    // [1 / f(x)]' = - f'(x) / f(x) ^ 2
+    // [1 / f(x)]' = - f'{x} / f(x) ^ 2
     def derivative(v: Var[T]) = Neg(Div(expr.derivative(v), Sqr(expr)))
     def eval(f: Any => Any) = num.div(num.one, expr.eval(f))
     def mapArgs(f: EndoFunction[Expr[_]]) = Inv(f(expr))
@@ -458,7 +458,7 @@ trait Pattern {
   }
 
   case class Sqr[T](expr: Expr[T])(implicit num: NumericOps[T]) extends OneArg[T] {
-    // [f(x) ^ 2]' = 2 * f(x) * f'(x)
+    // [f(x) ^ 2]' = 2 * f(x) * f'{x}
     def derivative(v: Var[T]) = Mul(Mul(Const(num.two), expr), expr.derivative(v))
     def eval(f: Any => Any) = num.sqr(expr.eval(f))
     def mapArgs(f: EndoFunction[Expr[_]]) = Sqr(f(expr))
diff --git a/tests/pos-with-compiler/quote-0.scala b/tests/pos-with-compiler/quote-0.scala
index 5d0f908f6602..020a62e2516d 100644
--- a/tests/pos-with-compiler/quote-0.scala
+++ b/tests/pos-with-compiler/quote-0.scala
@@ -5,20 +5,20 @@ import scala.quoted.Toolbox.Default._
 object Macros {
 
   inline def assert(expr: => Boolean): Unit =
-    ~assertImpl('(expr))
+    ${ assertImpl('expr) }
 
   def assertImpl(expr: Expr[Boolean]) =
-    '{ if !(~expr) then throw new AssertionError(s"failed assertion: ${~showExpr(expr)}") }
+    '{ if !($expr) then throw new AssertionError(s"failed assertion: ${${showExpr(expr)}}") }
 
   def showExpr[T](expr: Expr[T]): Expr[String] = expr.toString.toExpr
 
-  inline def power(inline n: Int, x: Double) = ~powerCode(n, '(x))
+  inline def power(inline n: Int, x: Double) = ${ powerCode(n, 'x) }
 
   def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
-    if (n == 0) '(1.0)
+    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 % 2 == 0) '{ { val y = $x * $x; ${ powerCode(n / 2, 'y) } } }
+    else '{ $x * ${ powerCode(n - 1, x) } }
 }
 
 class Test {
@@ -29,13 +29,13 @@ class Test {
     val x = 1
     assert(x != 0)
 
-    ~assertImpl('(x != 0))
+    ${ assertImpl('{x != 0}) }
 
     val y = math.sqrt(2.0)
 
     power(3, y)
 
-    ~powerCode(3, '{math.sqrt(2.0)})
+    ${ powerCode(3, '{math.sqrt(2.0)}) }
   }
 
   program.run
diff --git a/tests/pos-with-compiler/quote-assert/quoted_1.scala b/tests/pos-with-compiler/quote-assert/quoted_1.scala
index 7cb0e73f5bc4..3f7bc8c69109 100644
--- a/tests/pos-with-compiler/quote-assert/quoted_1.scala
+++ b/tests/pos-with-compiler/quote-assert/quoted_1.scala
@@ -2,5 +2,5 @@ import scala.quoted._
 
 object Macros {
   def assertImpl(expr: Expr[Boolean]) =
-    '{ if !(~expr) then throw new AssertionError(s"failed assertion: ${~expr}") }
+    '{ if !($expr) then throw new AssertionError(s"failed assertion: ${$expr}") }
 }
diff --git a/tests/pos-with-compiler/quote-assert/quoted_2.scala b/tests/pos-with-compiler/quote-assert/quoted_2.scala
index 45a955b0648f..50d835cace3f 100644
--- a/tests/pos-with-compiler/quote-assert/quoted_2.scala
+++ b/tests/pos-with-compiler/quote-assert/quoted_2.scala
@@ -5,14 +5,14 @@ import Macros._
 object Test {
 
   inline def assert(expr: => Boolean): Unit =
-    ~ assertImpl('(expr))
+    ${ assertImpl('expr) }
 
 
   val program = '{
     val x = 1
     assert(x != 0)
 
-    ~assertImpl('(x != 0))
+    ${ assertImpl('{x != 0}) }
   }
 
   program.run
diff --git a/tests/pos/i3898/quoted_1.scala b/tests/pos/i3898/quoted_1.scala
index 61fa38781138..8d2b3d2c5d87 100644
--- a/tests/pos/i3898/quoted_1.scala
+++ b/tests/pos/i3898/quoted_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff(args: Any*): String = ~impl('(args))
-  def impl(args: Expr[Seq[Any]]): Expr[String] = '("")
+  inline def ff(args: Any*): String = ${impl('args)}
+  def impl(args: Expr[Seq[Any]]): Expr[String] = '{""}
 }
diff --git a/tests/pos/i3898b/quoted_1.scala b/tests/pos/i3898b/quoted_1.scala
index fb2072ab4cb9..fa05e2fc2f93 100644
--- a/tests/pos/i3898b/quoted_1.scala
+++ b/tests/pos/i3898b/quoted_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff(x: Int, inline y: Int): String = ~impl('(x))
-  def impl(x: Expr[Int]): Expr[String] = '("")
+  inline def ff(x: Int, inline y: Int): String = ${impl('x)}
+  def impl(x: Expr[Int]): Expr[String] = '{""}
 }
diff --git a/tests/pos/i3898c/quoted_1.scala b/tests/pos/i3898c/quoted_1.scala
index fb2072ab4cb9..fa05e2fc2f93 100644
--- a/tests/pos/i3898c/quoted_1.scala
+++ b/tests/pos/i3898c/quoted_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff(x: Int, inline y: Int): String = ~impl('(x))
-  def impl(x: Expr[Int]): Expr[String] = '("")
+  inline def ff(x: Int, inline y: Int): String = ${impl('x)}
+  def impl(x: Expr[Int]): Expr[String] = '{""}
 }
diff --git a/tests/pos/i3912-1/i3912_1.scala b/tests/pos/i3912-1/i3912_1.scala
index 80faaf976743..faa6c82a4ca8 100644
--- a/tests/pos/i3912-1/i3912_1.scala
+++ b/tests/pos/i3912-1/i3912_1.scala
@@ -1,7 +1,7 @@
 import scala.quoted._
 
 object Macros {
-  inline def foo(): Int = { ~impl() }
+  inline def foo(): Int = { ${ impl() } }
 
-  def impl(): Expr[Int] = '(1)
+  def impl(): Expr[Int] = '{1}
 }
\ No newline at end of file
diff --git a/tests/pos/i3912-2/i3912_1.scala b/tests/pos/i3912-2/i3912_1.scala
index e3d1ba91df37..b6912a6efa74 100644
--- a/tests/pos/i3912-2/i3912_1.scala
+++ b/tests/pos/i3912-2/i3912_1.scala
@@ -1,7 +1,7 @@
 import scala.quoted._
 
 object Macros {
-  inline def foo2(): Unit = ~impl()
+  inline def foo2(): Unit = ${ impl() }
 
-  def impl(): Expr[Int] = '(1)
+  def impl(): Expr[Int] = '{1}
 }
\ No newline at end of file
diff --git a/tests/pos/i3912-3/i3912_1.scala b/tests/pos/i3912-3/i3912_1.scala
index a544cfd26282..c1df47e41db6 100644
--- a/tests/pos/i3912-3/i3912_1.scala
+++ b/tests/pos/i3912-3/i3912_1.scala
@@ -3,9 +3,9 @@ import scala.quoted._
 object Macros {
   inline def foo3(): Int = {
     {
-      ~impl()
+      ${ impl() }
     }
   }
 
-  def impl(): Expr[Int] = '(1)
+  def impl(): Expr[Int] = '{1}
 }
\ No newline at end of file
diff --git a/tests/pos/i4023/Macro_1.scala b/tests/pos/i4023/Macro_1.scala
index b51c1de87b2e..34551e3123fc 100644
--- a/tests/pos/i4023/Macro_1.scala
+++ b/tests/pos/i4023/Macro_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff[T: Type](x: T): T = ~impl('(x))
+  inline def ff[T: Type](x: T): T = ${ impl('x) }
   def impl[T](x: Expr[T]): Expr[T] = x
 }
diff --git a/tests/pos/i4023b/Macro_1.scala b/tests/pos/i4023b/Macro_1.scala
index e440b4e1923a..bad8763aeeb2 100644
--- a/tests/pos/i4023b/Macro_1.scala
+++ b/tests/pos/i4023b/Macro_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff[T](implicit t: Type[T]): Int = ~impl[T]
-  def impl[T]: Expr[Int] = '(4)
+  inline def ff[T](implicit t: Type[T]): Int = ${ impl[T] }
+  def impl[T]: Expr[Int] = '{4}
 }
diff --git a/tests/pos/i4023c/Macro_1.scala b/tests/pos/i4023c/Macro_1.scala
index 5888856ff83e..f21f8a9e9012 100644
--- a/tests/pos/i4023c/Macro_1.scala
+++ b/tests/pos/i4023c/Macro_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff[T](x: T): T = ~impl('(x))('[T])
-  def impl[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{ (~x): ~t }
+  inline def ff[T](x: T): T = ${ impl('x)('[T]) }
+  def impl[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{ $x: $t }
 }
diff --git a/tests/pos/i4350.scala b/tests/pos/i4350.scala
index 7c6a82145cc9..46616bbcff10 100644
--- a/tests/pos/i4350.scala
+++ b/tests/pos/i4350.scala
@@ -1,5 +1,5 @@
 import scala.quoted.Type
 
 class Foo[T: Type] {
-  '(null.asInstanceOf[T])
+  '{null.asInstanceOf[T]}
 }
diff --git a/tests/pos/i4380a.scala b/tests/pos/i4380a.scala
index fefd5cc8b0f0..be0a710ff55c 100644
--- a/tests/pos/i4380a.scala
+++ b/tests/pos/i4380a.scala
@@ -14,7 +14,7 @@ object Test {
       case Bar(producer, nestedf) => {
         new Producer[Expr[A]] {
           def step(k: Expr[A] => Expr[Unit]): Expr[Unit] = '{
-            val adv: Unit => Unit = { _ => ~producer.step((el) => nestedf(el))}
+            val adv: Unit => Unit = { _ => ${producer.step((el) => nestedf(el))} }
           }
         }
       }
diff --git a/tests/pos/i4380b.scala b/tests/pos/i4380b.scala
index b305780e0843..864d02d21885 100644
--- a/tests/pos/i4380b.scala
+++ b/tests/pos/i4380b.scala
@@ -1,8 +1,8 @@
 import scala.quoted._
 
 object Test {
-  def step(k: (String => Expr[Unit])): Expr[Unit] = '()
+  def step(k: (String => Expr[Unit])): Expr[Unit] = '{}
   def meth(): Unit = '{
-    (i: Int) => ~step(el => '() )
+    (i: Int) => ${ step(el => '{} ) }
   }
 }
diff --git a/tests/pos/i4396a.scala b/tests/pos/i4396a.scala
index 0a69f685f986..294783b91eec 100644
--- a/tests/pos/i4396a.scala
+++ b/tests/pos/i4396a.scala
@@ -1,3 +1,3 @@
 class Test {
-  '(Option(4) match { case Some(a) => a; case None => 1 })
+  '{ Option(4) match { case Some(a) => a; case None => 1 }}
 }
\ No newline at end of file
diff --git a/tests/pos/i4493-c.scala b/tests/pos/i4493-c.scala
index 08327e5fa81a..3ced80d53e22 100644
--- a/tests/pos/i4493-c.scala
+++ b/tests/pos/i4493-c.scala
@@ -1,6 +1,6 @@
 class Index[K]
 object Index {
-  inline def succ[K]: Unit = ~{
-    '(new Index[K])
+  inline def succ[K]: Unit = ${
+    '{new Index[K]}
   }
 }
diff --git a/tests/pos/i4514.scala b/tests/pos/i4514.scala
index 0da1e9af33f7..97388c9334f8 100644
--- a/tests/pos/i4514.scala
+++ b/tests/pos/i4514.scala
@@ -1,4 +1,4 @@
 object Foo {
-  inline def foo[X](x: X): Unit = ~fooImpl('(x))
-  def fooImpl[X: quoted.Type](x: X): quoted.Expr[Unit] = '()
+  inline def foo[X](x: X): Unit = ${fooImpl('x)}
+  def fooImpl[X: quoted.Type](x: X): quoted.Expr[Unit] = '{}
 }
diff --git a/tests/pos/i4734/Macro_1.scala b/tests/pos/i4734/Macro_1.scala
index ecc8357c3d4b..740b70a134e0 100644
--- a/tests/pos/i4734/Macro_1.scala
+++ b/tests/pos/i4734/Macro_1.scala
@@ -3,10 +3,10 @@ import scala.quoted._
 
 object Macros {
   inline def unrolledForeach(f: Int => Int): Int =
-  ~unrolledForeachImpl('(f))
+   ${unrolledForeachImpl('f)}
 
   def unrolledForeachImpl(f: Expr[Int => Int]): Expr[Int] = '{
     val size: Int = 5
-    (~f)(3)
+    ($f)(3)
   }
 }
diff --git a/tests/pos/i4773.scala b/tests/pos/i4773.scala
index b829f25c0e33..63e73f910586 100644
--- a/tests/pos/i4773.scala
+++ b/tests/pos/i4773.scala
@@ -1,7 +1,7 @@
 import scala.quoted._
 
 object Foo {
-  inline def foo2(): Unit = ~foo2Impl()
-  def foo2Impl(): Expr[Unit] = '()
+  inline def foo2(): Unit = ${foo2Impl()}
+  def foo2Impl(): Expr[Unit] = '{}
   inline def foo(): Unit = foo2()
 }
diff --git a/tests/pos/i4774a.scala b/tests/pos/i4774a.scala
index 6a1f6ec0588e..d8ceda47f7e2 100644
--- a/tests/pos/i4774a.scala
+++ b/tests/pos/i4774a.scala
@@ -3,7 +3,7 @@ import scala.quoted._
 
 object Test {
   def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{
-    val y: ~t = ~x
-    ~loop('(y))
+    val y: $t = $x
+    ${loop('y)}
   }
 }
diff --git a/tests/pos/i4774c.scala b/tests/pos/i4774c.scala
index 8282616259d3..a67e8abc444e 100644
--- a/tests/pos/i4774c.scala
+++ b/tests/pos/i4774c.scala
@@ -2,5 +2,5 @@
 import scala.quoted._
 
 object Test {
-  def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{ val y = ~x; ~loop('(y)) }
+  def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{ val y = $x; ${loop('y)} }
 }
diff --git a/tests/pos/i4774d.scala b/tests/pos/i4774d.scala
index 2a17e34b4f8f..6ab3239b6625 100644
--- a/tests/pos/i4774d.scala
+++ b/tests/pos/i4774d.scala
@@ -3,5 +3,5 @@ import scala.quoted._
 
 object Test {
   def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] =
-    '{ val y: T = ~x; ~loop('(y)) }
+    '{ val y: T = $x; ${loop('y)} }
 }
diff --git a/tests/pos/i4774e.scala b/tests/pos/i4774e.scala
index d836c86093d8..35ee2dfea9ab 100644
--- a/tests/pos/i4774e.scala
+++ b/tests/pos/i4774e.scala
@@ -3,8 +3,8 @@ import scala.quoted._
 
 object Test {
   def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] =
-    '{ def y = ~x; ~loop('(y)) }
+    '{ def y = $x; ${ loop('y) } }
 
   def loop2[T](x: Expr[T])(implicit t: Type[T]): Expr[T] =
-  '{ def y() = ~x; ~loop('(y())) }
+  '{ def y() = $x; ${ loop('{y()}) } }
 }
diff --git a/tests/pos/i4774f.scala b/tests/pos/i4774f.scala
index 37b6031e8fb6..c9b76b1b3688 100644
--- a/tests/pos/i4774f.scala
+++ b/tests/pos/i4774f.scala
@@ -3,8 +3,8 @@ import scala.quoted._
 
 object Test {
   def loop[T](x: Expr[T])(implicit t: Type[T]): Expr[T] =
-    '{ def y: T = ~x; ~loop('(y)) }
+    '{ def y: T = $x; ${ loop('y) } }
 
   def loop2[T](x: Expr[T])(implicit t: Type[T]): Expr[T] =
-  '{ def y(): T = ~x; ~loop('(y())) }
+  '{ def y(): T = $x; ${ loop('{y()}) } }
 }
diff --git a/tests/pos/i4846.scala b/tests/pos/i4846.scala
index c97c21777218..a8007c29b7dd 100644
--- a/tests/pos/i4846.scala
+++ b/tests/pos/i4846.scala
@@ -1,6 +1,6 @@
 import scala.quoted._
 
 object Test {
-  inline def foo(inline x: Int): Int = ~fooImpl(x, '(x), '( '(x) ), '( '( '(x) ) ))
+  inline def foo(inline x: Int): Int = ${fooImpl(x, 'x, '{ 'x }, '{ '{ 'x } })}
   def fooImpl(a: Int, b: Expr[Int], c: Expr[Expr[Int]], d: Expr[Expr[Expr[Int]]]): Expr[Int] = ???
 }
diff --git a/tests/pos/i4891.scala b/tests/pos/i4891.scala
index e59e57968765..cf2189093280 100644
--- a/tests/pos/i4891.scala
+++ b/tests/pos/i4891.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 
 object Test {
-  def foo: Expr[Option[String]] = '(None)
+  def foo: Expr[Option[String]] = '{None}
 }
diff --git a/tests/pos/i5954.scala b/tests/pos/i5954.scala
index eafc053e6b71..1a291ba21b3e 100644
--- a/tests/pos/i5954.scala
+++ b/tests/pos/i5954.scala
@@ -6,10 +6,10 @@ object MatcherFactory1 {
   import scala.quoted._
 
   def impl(self: Expr[MatcherFactory1#AndNotWord]) =
-    '{ ~self }
+    '{ val a: Any = $self }
 
 
   def impl2[T: Type](a: MatcherFactory1)(self: Expr[T])(implicit ev: T =:= a.AndNotWord) =
-    '{ ~self }
+    '{ val a: Any = $self }
 
 }
diff --git a/tests/pos/macro-with-array/Macro_1.scala b/tests/pos/macro-with-array/Macro_1.scala
index a115aa3dc036..a0fb439faca5 100644
--- a/tests/pos/macro-with-array/Macro_1.scala
+++ b/tests/pos/macro-with-array/Macro_1.scala
@@ -1,29 +1,29 @@
 
 object Macro {
 
-  inline def foo0(i: Int): Unit = ~{ '() }
-  inline def foo1(arr: Array[Boolean]): Unit = ~{ '() }
-  inline def foo2(arr: Array[Byte]): Unit = ~{ '() }
-  inline def foo3(arr: Array[Short]): Unit = ~{ '() }
-  inline def foo4(arr: Array[Int]): Unit = ~{ '() }
-  inline def foo5(arr: Array[Long]): Unit = ~{ '() }
-  inline def foo6(arr: Array[Float]): Unit = ~{ '() }
-  inline def foo7(arr: Array[Double]): Unit = ~{ '() }
-  inline def foo8(arr: Array[Char]): Unit = ~{ '() }
-  inline def foo9(arr: Array[Object]): Unit = ~{ '() }
-  inline def foo10(arr: Array[String]): Unit = ~{ '() }
-  inline def foo11[T](arr: Array[T]): Unit = ~{ '() }
-  inline def foo12(arr: Array[Array[Int]]): Unit = ~{ '() }
-  inline def foo13(arr: Array[Array[String]]): Unit = ~{ '() }
-  inline def foo14(arr: Array[Array[Array[Int]]]): Unit = ~{ '() }
-  inline def foo15(arr: Array[Any]): Unit = ~{ '() }
-  inline def foo16(arr: Array[AnyVal]): Unit = ~{ '() }
-  inline def foo17(arr: Array[AnyRef]): Unit = ~{ '() }
-  inline def foo18(arr: Array[Foo]): Unit = ~{ '() }
-  inline def foo19(arr: Array[Macro.type]): Unit = ~{ '() }
-  inline def foo20(arr: Array[Bar]): Unit = ~{ '() }
-  inline def foo21(arr: Array[Baz.type]): Unit = ~{ '() }
-  inline def foo22(arr: Array[Foo#A]): Unit = ~{ '() }
+  inline def foo0(i: Int): Unit = ${ '{} }
+  inline def foo1(arr: Array[Boolean]): Unit = ${ '{} }
+  inline def foo2(arr: Array[Byte]): Unit = ${ '{} }
+  inline def foo3(arr: Array[Short]): Unit = ${ '{} }
+  inline def foo4(arr: Array[Int]): Unit = ${ '{} }
+  inline def foo5(arr: Array[Long]): Unit = ${ '{} }
+  inline def foo6(arr: Array[Float]): Unit = ${ '{} }
+  inline def foo7(arr: Array[Double]): Unit = ${ '{} }
+  inline def foo8(arr: Array[Char]): Unit = ${ '{} }
+  inline def foo9(arr: Array[Object]): Unit = ${ '{} }
+  inline def foo10(arr: Array[String]): Unit = ${ '{} }
+  inline def foo11[T](arr: Array[T]): Unit = ${ '{} }
+  inline def foo12(arr: Array[Array[Int]]): Unit = ${ '{} }
+  inline def foo13(arr: Array[Array[String]]): Unit = ${ '{} }
+  inline def foo14(arr: Array[Array[Array[Int]]]): Unit = ${ '{} }
+  inline def foo15(arr: Array[Any]): Unit = ${ '{} }
+  inline def foo16(arr: Array[AnyVal]): Unit = ${ '{} }
+  inline def foo17(arr: Array[AnyRef]): Unit = ${ '{} }
+  inline def foo18(arr: Array[Foo]): Unit = ${ '{} }
+  inline def foo19(arr: Array[Macro.type]): Unit = ${ '{} }
+  inline def foo20(arr: Array[Bar]): Unit = ${ '{} }
+  inline def foo21(arr: Array[Baz.type]): Unit = ${ '{} }
+  inline def foo22(arr: Array[Foo#A]): Unit = ${ '{} }
 
   class Bar
   object Baz
diff --git a/tests/pos/macro-with-type/Macro_1.scala b/tests/pos/macro-with-type/Macro_1.scala
index f6da5bf47794..c515c8a51ccc 100644
--- a/tests/pos/macro-with-type/Macro_1.scala
+++ b/tests/pos/macro-with-type/Macro_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
-  inline def ff: Unit = ~impl('[Int])
-  def impl(t: Type[Int]): Expr[Unit] = '()
+  inline def ff: Unit = ${impl('[Int])}
+  def impl(t: Type[Int]): Expr[Unit] = '{}
 }
diff --git a/tests/pos/power-macro/Macro_1.scala b/tests/pos/power-macro/Macro_1.scala
index e279c7efd180..53179247dd66 100644
--- a/tests/pos/power-macro/Macro_1.scala
+++ b/tests/pos/power-macro/Macro_1.scala
@@ -3,10 +3,10 @@ import scala.quoted.Expr
 
 object PowerMacro {
 
-  inline def power(inline n: Long, x: Double) = ~powerCode(n, '(x))
+  inline def power(inline n: Long, x: Double) = ${powerCode(n, 'x)}
 
   def powerCode(n: Long, x: Expr[Double]): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ { val y = ~x * ~x; ~powerCode(n / 2, '(y)) } }
-    else '{ ~x * ~powerCode(n - 1, x) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ { val y = $x * $x; ${powerCode(n / 2, 'y)} } }
+    else '{ $x * ${powerCode(n - 1, x)} }
 }
diff --git a/tests/pos/quote-1.scala b/tests/pos/quote-1.scala
index 669a0037b6bf..5772b7d49c1e 100644
--- a/tests/pos/quote-1.scala
+++ b/tests/pos/quote-1.scala
@@ -3,14 +3,14 @@ import scala.quoted._
 object Test {
 
   def f[T](x: Expr[T])(implicit t: Type[T]) = '{
-    val y: t.unary_~ = x.unary_~
-    val z = ~x
+    val y: $t = $x
+    val z = $x
   }
 
-  f('(2))('[Int])
+  f('{2})('[Int])
    f('{ true })('[Boolean])
 
   def g(es: Expr[String], t: Type[String]) =
-    f('{ (~es + "!") :: Nil })('[List[~t]])
+    f('{ ($es + "!") :: Nil })('[List[$t]])
 }
 
diff --git a/tests/pos/quote-bind-T.scala b/tests/pos/quote-bind-T.scala
index 482eafc0a49e..2884ec6e22d5 100644
--- a/tests/pos/quote-bind-T.scala
+++ b/tests/pos/quote-bind-T.scala
@@ -3,7 +3,7 @@ import scala.quoted._
 
 object Test {
   def matchX[T](x: Expr[T])(implicit t: Type[T]): Expr[T] = '{
-    (~x) match {
+    $x match {
       case y: T => y
     }
   }
diff --git a/tests/pos/quote-lift-inline-params-b.scala b/tests/pos/quote-lift-inline-params-b.scala
index 8bfed3e7436a..fd8d0ad25024 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 {
-  inline def foo(inline n: Int): Int = ~{
-    '(n)
+  inline def foo(inline n: Int): Int = ${
+    '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 953cff392ca2..980c493558f8 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 => _}
-  inline def foo(inline n: Int): Int = ~{
-    '(n)
+  inline def foo(inline n: Int): Int = ${
+    'n
   }
 }
\ No newline at end of file
diff --git a/tests/pos/quote-lift.scala b/tests/pos/quote-lift.scala
index 1ec60672d34d..7d3a00322a14 100644
--- a/tests/pos/quote-lift.scala
+++ b/tests/pos/quote-lift.scala
@@ -2,14 +2,14 @@ import scala.quoted._
 
 object Test {
 
-  '{ ~implicitly[Liftable[Int]].toExpr(1) }
+  '{ ${implicitly[Liftable[Int]].toExpr(1)} }
 
   {
     import Liftable._
 
-    '{ ~IntIsLiftable.toExpr(1) }
+    '{ ${IntIsLiftable.toExpr(1)} }
 
-    '{ ~1.toExpr }
+    '{ ${1.toExpr} }
 
   }
 
diff --git a/tests/pos/quote-liftable-list-2.scala b/tests/pos/quote-liftable-list-2.scala
index e249c388d475..6c946cc36334 100644
--- a/tests/pos/quote-liftable-list-2.scala
+++ b/tests/pos/quote-liftable-list-2.scala
@@ -3,11 +3,11 @@ import scala.quoted._
 object Test {
 
   implicit def ListIsLiftableOr[T: Type, U: Type]: Liftable[List[T | U]] = new {
-    def toExpr(xs: List[T | U]): Expr[List[T | U]] = '(Nil: List[T | U])
+    def toExpr(xs: List[T | U]): Expr[List[T | U]] = '{ Nil: List[T | U] }
   }
 
   implicit def ListIsLiftableAnd[T: Type, U: Type]: Liftable[List[T & U]] = new {
-    def toExpr(xs: List[T & U]): Expr[List[T & U]] = '(Nil: List[T & U])
+    def toExpr(xs: List[T & U]): Expr[List[T & U]] = '{ Nil: List[T & U] }
   }
 
 }
diff --git a/tests/pos/quote-liftable-list.scala b/tests/pos/quote-liftable-list.scala
index fdefe80801a4..7b5e091b8b80 100644
--- a/tests/pos/quote-liftable-list.scala
+++ b/tests/pos/quote-liftable-list.scala
@@ -3,7 +3,7 @@ import scala.quoted._
 object Test {
 
   implicit def ListIsLiftable[T: Liftable: Type]: Liftable[List[T]] = new {
-    def toExpr(xs: List[T]): Expr[List[T]] = '(Nil: List[T])
+    def toExpr(xs: List[T]): Expr[List[T]] = '{ Nil: List[T] }
   }
 
 }
diff --git a/tests/pos/quote-liftable.scala b/tests/pos/quote-liftable.scala
index 2edb101fdaa9..8b031f208498 100644
--- a/tests/pos/quote-liftable.scala
+++ b/tests/pos/quote-liftable.scala
@@ -4,23 +4,23 @@ object Test {
 
   implicit def IntIsLiftable: Liftable[Int] = new {
     def toExpr(n: Int): Expr[Int] = n match {
-      case Int.MinValue    => '(Int.MinValue)
-      case _ if n < 0      => '(-(~toExpr(n)))
-      case 0               => '(0)
-      case _ if n % 2 == 0 => '( ~toExpr(n / 2) * 2)
-      case _               => '( ~toExpr(n / 2) * 2 + 1)
+      case Int.MinValue    => '{Int.MinValue}
+      case _ if n < 0      => '{- ${toExpr(n)}}
+      case 0               => '{0}
+      case _ if n % 2 == 0 => '{ ${toExpr(n / 2)} * 2 }
+      case _               => '{ ${toExpr(n / 2)} * 2 + 1 }
     }
   }
 
   implicit def BooleanIsLiftable: Liftable[Boolean] = new {
     implicit def toExpr(b: Boolean) =
-      if (b) '(true) else '(false)
+      if (b) '{true} else '{false}
   }
 
   implicit def ListIsLiftable[T: Liftable: Type]: Liftable[List[T]] = new {
     def toExpr(xs: List[T]): Expr[List[T]] = xs match {
-      case x :: xs1 => '{ ~implicitly[Liftable[T]].toExpr(x) :: ~toExpr(xs1) }
-      case Nil => '(Nil: List[T])
+      case x :: xs1 => '{ ${ implicitly[Liftable[T]].toExpr(x) } :: ${ toExpr(xs1) } }
+      case Nil => '{Nil: List[T]}
     }
   }
 
diff --git a/tests/pos/quote-nested-object/Macro_1.scala b/tests/pos/quote-nested-object/Macro_1.scala
index a24a6dd3f376..cf5fdce507b4 100644
--- a/tests/pos/quote-nested-object/Macro_1.scala
+++ b/tests/pos/quote-nested-object/Macro_1.scala
@@ -6,19 +6,19 @@ object Macro {
 
   object Implementation {
 
-    inline def plus(inline n: Int, m: Int): Int = ~plus(n, '(m))
+    inline def plus(inline n: Int, m: Int): Int = ${ plus(n, 'm) }
 
     def plus(n: Int, m: Expr[Int]): Expr[Int] =
       if (n == 0) m
-      else '{ ~n.toExpr + ~m }
+      else '{ ${n.toExpr} + $m }
 
     object Implementation2 {
 
-      inline def plus(inline n: Int, m: Int): Int = ~plus(n, '(m))
+      inline def plus(inline n: Int, m: Int): Int = ${ plus(n, 'm) }
 
       def plus(n: Int, m: Expr[Int]): Expr[Int] =
         if (n == 0) m
-        else '{ ~n.toExpr + ~m }
+        else '{ ${n.toExpr} + $m }
     }
   }
 
diff --git a/tests/pos/quote-non-static-macro.scala b/tests/pos/quote-non-static-macro.scala
index a6043b2d10f1..5b2bcb19a05d 100644
--- a/tests/pos/quote-non-static-macro.scala
+++ b/tests/pos/quote-non-static-macro.scala
@@ -1,18 +1,18 @@
 import scala.quoted._
 
 class Foo {
-  inline def foo: Unit = ~Foo.impl
+  inline def foo: Unit = ${Foo.impl}
   object Bar {
-    inline def foo: Unit = ~Foo.impl
+    inline def foo: Unit = ${Foo.impl}
   }
 }
 
 object Foo {
   class Baz {
-    inline def foo: Unit = ~impl
+    inline def foo: Unit = ${impl}
   }
   object Quox {
-    inline def foo: Unit = ~Foo.impl
+    inline def foo: Unit = ${Foo.impl}
   }
-  def impl: Expr[Unit] = '()
+  def impl: Expr[Unit] = '{}
 }
diff --git a/tests/pos/quote-this.scala b/tests/pos/quote-this.scala
index 2472188ce2b3..b06e30b29b69 100644
--- a/tests/pos/quote-this.scala
+++ b/tests/pos/quote-this.scala
@@ -1,28 +1,28 @@
 import scala.quoted._
 
 class Foo {
-  def a: Expr[Int] = '(1)
+  def a: Expr[Int] = '{1}
   def b: Expr[Int] = '{
-    ~this.a
+    ${ this.a }
   }
 
-  def d: Expr[Expr[Int]] = '{ '(1) }
+  def d: Expr[Expr[Int]] = '{ '{1} }
   def e: Expr[Expr[Int]] = '{
-    '( ~(~this.d) )
+    '{${${this.d}}}
   }
 
   def foo[T](x: T): T = x
 
   def f = '{
-    ~foo[this.type](this).a
+    ${ foo[this.type](this).a }
   }
 
-  inline def g(): Unit = ~Foo.impl[this.type](1)
-  inline def h(): Unit = ~Foo.impl[Any]('(this))
-  inline def i(that: Foo): Unit = ~Foo.impl[that.type](1)
+  inline def g(): Unit = ${ Foo.impl[this.type](1) }
+  inline def h(): Unit = ${ Foo.impl[Any]('this) }
+  inline def i(that: Foo): Unit = ${ Foo.impl[that.type](1) }
 
 }
 
 object Foo {
-  def impl[T](x: Any): Expr[Unit] = '()
+  def impl[T](x: Any): Expr[Unit] = '{}
 }
diff --git a/tests/pos/spliceTest.scala b/tests/pos/spliceTest.scala
deleted file mode 100644
index c04afdcecb57..000000000000
--- a/tests/pos/spliceTest.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-class Expr[T] {
-  def unary_~ : T = ???
-}
-class Type[T] {
-  type unary_~ = T
-}
-object Test {
-
-  def f[T](t: Type[T], x: Expr[T]) = {
-    val y: t.unary_~ = x.unary_~
-    val z: ~t = ~x
-  }
-
-}
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
index dd9aa5a6d917..f3c519c1490f 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
@@ -4,7 +4,7 @@ import scala.tasty._
 object Foo {
 
   inline def inspectBody(i: => Int): String =
-    ~inspectBodyImpl('(i))
+    ${ inspectBodyImpl('i) }
 
   def inspectBodyImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
index 6cef0ad48ab5..a491db7ae672 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
@@ -4,7 +4,7 @@ import scala.tasty._
 object Foo {
 
   inline def inspectBody(i: => Int): String =
-    ~inspectBodyImpl('(i))
+    ${ inspectBodyImpl('i) }
 
   def inspectBodyImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
diff --git a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check
index 114de84021de..ad142704cb0a 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners.check
@@ -1,5 +1,5 @@
 foo
-DefDef("main", Nil, List(List(ValDef("args", TypeTree.Applied(TypeTree.Ident("Array"), List(TypeTree.Ident("String"))), None))), TypeTree.Ident("Unit"), Some(Term.Block(Nil, Term.Inlined(Some(TypeTree.Ident("Macros$")), Nil, Term.Typed(Term.Select(Term.Apply(Term.Apply(Term.TypeApply(Term.Ident("impl"), List(TypeTree.Inferred())), List(Term.Apply(Term.TypeApply(Term.Ident("apply"), List(TypeTree.Inferred())), List(Term.Inlined(None, Nil, Term.Block(List(DefDef("foo", Nil, Nil, TypeTree.Inferred(), Some(Term.Block(List(DefDef("bar", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1)))), ValDef("bar2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(2))))), Term.Typed(Term.Ident("bar"), TypeTree.Inferred())))), ValDef("foo2", TypeTree.Inferred(), Some(Term.Block(List(DefDef("baz", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(3)))), ValDef("baz2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(4))))), Term.Typed(Term.Ident("baz"), TypeTree.Inferred())))), ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("B", TypeTree.Ident("Int")), DefDef("b", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(5)))), ValDef("b2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(6))))))), Term.Literal(Constant.Unit()))))))), List(Term.Ident("macroContext"))), "unary_~"), TypeTree.Ident("Unit"))))))
+DefDef("main", Nil, List(List(ValDef("args", TypeTree.Applied(TypeTree.Ident("Array"), List(TypeTree.Ident("String"))), None))), TypeTree.Ident("Unit"), Some(Term.Block(Nil, Term.Inlined(Some(TypeTree.Ident("Macros$")), Nil, Term.Typed(Term.Select(Term.Apply(Term.Apply(Term.TypeApply(Term.Ident("impl"), List(TypeTree.Inferred())), List(Term.Apply(Term.TypeApply(Term.Ident("apply"), List(TypeTree.Inferred())), List(Term.Inlined(None, Nil, Term.Block(List(DefDef("foo", Nil, Nil, TypeTree.Inferred(), Some(Term.Block(List(DefDef("bar", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1)))), ValDef("bar2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(2))))), Term.Typed(Term.Ident("bar"), TypeTree.Inferred())))), ValDef("foo2", TypeTree.Inferred(), Some(Term.Block(List(DefDef("baz", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(3)))), ValDef("baz2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(4))))), Term.Typed(Term.Ident("baz"), TypeTree.Inferred())))), ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("B", TypeTree.Ident("Int")), DefDef("b", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(5)))), ValDef("b2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(6))))))), Term.Literal(Constant.Unit()))))))), List(Term.Ident("macroContext"))), "$splice"), TypeTree.Ident("Unit"))))))
 
 bar
 DefDef("foo", Nil, Nil, TypeTree.Inferred(), Some(Term.Block(List(DefDef("bar", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1)))), ValDef("bar2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(2))))), Term.Typed(Term.Ident("bar"), TypeTree.Inferred()))))
@@ -8,7 +8,7 @@ bar2
 DefDef("foo", Nil, Nil, TypeTree.Inferred(), Some(Term.Block(List(DefDef("bar", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1)))), ValDef("bar2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(2))))), Term.Typed(Term.Ident("bar"), TypeTree.Inferred()))))
 
 foo2
-DefDef("main", Nil, List(List(ValDef("args", TypeTree.Applied(TypeTree.Ident("Array"), List(TypeTree.Ident("String"))), None))), TypeTree.Ident("Unit"), Some(Term.Block(Nil, Term.Inlined(Some(TypeTree.Ident("Macros$")), Nil, Term.Typed(Term.Select(Term.Apply(Term.Apply(Term.TypeApply(Term.Ident("impl"), List(TypeTree.Inferred())), List(Term.Apply(Term.TypeApply(Term.Ident("apply"), List(TypeTree.Inferred())), List(Term.Inlined(None, Nil, Term.Block(List(DefDef("foo", Nil, Nil, TypeTree.Inferred(), Some(Term.Block(List(DefDef("bar", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1)))), ValDef("bar2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(2))))), Term.Typed(Term.Ident("bar"), TypeTree.Inferred())))), ValDef("foo2", TypeTree.Inferred(), Some(Term.Block(List(DefDef("baz", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(3)))), ValDef("baz2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(4))))), Term.Typed(Term.Ident("baz"), TypeTree.Inferred())))), ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("B", TypeTree.Ident("Int")), DefDef("b", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(5)))), ValDef("b2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(6))))))), Term.Literal(Constant.Unit()))))))), List(Term.Ident("macroContext"))), "unary_~"), TypeTree.Ident("Unit"))))))
+DefDef("main", Nil, List(List(ValDef("args", TypeTree.Applied(TypeTree.Ident("Array"), List(TypeTree.Ident("String"))), None))), TypeTree.Ident("Unit"), Some(Term.Block(Nil, Term.Inlined(Some(TypeTree.Ident("Macros$")), Nil, Term.Typed(Term.Select(Term.Apply(Term.Apply(Term.TypeApply(Term.Ident("impl"), List(TypeTree.Inferred())), List(Term.Apply(Term.TypeApply(Term.Ident("apply"), List(TypeTree.Inferred())), List(Term.Inlined(None, Nil, Term.Block(List(DefDef("foo", Nil, Nil, TypeTree.Inferred(), Some(Term.Block(List(DefDef("bar", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(1)))), ValDef("bar2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(2))))), Term.Typed(Term.Ident("bar"), TypeTree.Inferred())))), ValDef("foo2", TypeTree.Inferred(), Some(Term.Block(List(DefDef("baz", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(3)))), ValDef("baz2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(4))))), Term.Typed(Term.Ident("baz"), TypeTree.Inferred())))), ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Inferred(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Inferred()), "<init>"), Nil)), Nil, None, List(TypeDef("B", TypeTree.Ident("Int")), DefDef("b", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(5)))), ValDef("b2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(6))))))), Term.Literal(Constant.Unit()))))))), List(Term.Ident("macroContext"))), "$splice"), TypeTree.Ident("Unit"))))))
 
 baz
 ValDef("foo2", TypeTree.Inferred(), Some(Term.Block(List(DefDef("baz", Nil, Nil, TypeTree.Inferred(), Some(Term.Literal(Constant.Int(3)))), ValDef("baz2", TypeTree.Inferred(), Some(Term.Literal(Constant.Int(4))))), Term.Typed(Term.Ident("baz"), TypeTree.Inferred()))))
diff --git a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
index 29e8aac4c1b8..8825ed30d64c 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Macros {
 
   implicit inline def printOwners[T](x: => T): Unit =
-    ~impl('(x))
+    ${ impl('x) }
 
   def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -42,7 +42,7 @@ object Macros {
 
     val tree = x.unseal
     output.traverseTree(tree)
-    '(print(~buff.result().toExpr))
+    '{print(${buff.result().toExpr})}
   }
 
 }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
index 23d98063465b..d286b1d30bdc 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Foo {
 
   inline def inspectBody(i: => Int): String =
-    ~inspectBodyImpl('(i))
+    ${ inspectBodyImpl('i) }
 
   def inspectBodyImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
@@ -14,7 +14,7 @@ object Foo {
       case IsClassSymbol(sym) => sym.tree.show.toExpr
       case IsDefSymbol(sym) => sym.tree.show.toExpr
       case IsValSymbol(sym) => sym.tree.show.toExpr
-      case _ => '("NO DEFINTION")
+      case _ => '{"NO DEFINTION"}
     }
 
     x.unseal match {
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
index 5729eb2822ec..6c7c985c935f 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Foo {
 
   inline def inspectBody(i: => Int): String =
-    ~inspectBodyImpl('(i))
+    ${ inspectBodyImpl('i) }
 
   def inspectBodyImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
@@ -14,7 +14,7 @@ object Foo {
       case IsClassSymbol(sym) => sym.tree.show.toExpr
       case IsDefSymbol(sym) => sym.tree.show.toExpr
       case IsValSymbol(sym) => sym.tree.show.toExpr
-      case _ => '("NO DEFINTION")
+      case _ => '{"NO DEFINTION"}
     }
 
     x.unseal match {
diff --git a/tests/run-with-compiler-custom-args/staged-streams_1.scala b/tests/run-with-compiler-custom-args/staged-streams_1.scala
index 775b2856541d..19090889d7bf 100644
--- a/tests/run-with-compiler-custom-args/staged-streams_1.scala
+++ b/tests/run-with-compiler-custom-args/staged-streams_1.scala
@@ -14,13 +14,15 @@ object Test {
 
   object Var {
     def apply[T: Type, U: Type](init: Expr[T])(body: Var[T] => Expr[U]): Expr[U] = '{
-      var x = ~init
-      ~body(
-        new Var[T] {
-          def get: Expr[T] = '(x)
-          def update(e: Expr[T]): Expr[Unit] = '{ x = ~e }
-        }
-      )
+      var x = $init
+      ${
+        body(
+          new Var[T] {
+            def get: Expr[T] = 'x
+            def update(e: Expr[T]): Expr[Unit] = '{ x = $e }
+          }
+        )
+      }
     }
   }
 
@@ -95,16 +97,17 @@ object Test {
       * @tparam W  the type of the accumulator
       * @return
       */
-     def fold[W: Type](z: Expr[W], f: ((Expr[W], Expr[A]) => Expr[W])): Expr[W] = {
-       Var(z) { s: Var[W] => '{
-           ~foldRaw[Expr[A]]((a: Expr[A]) => '{
-             ~s.update(f(s.get, a))
-           }, stream)
-
-           ~s.get
-         }
-       }
-     }
+    def fold[W: Type](z: Expr[W], f: ((Expr[W], Expr[A]) => Expr[W])): Expr[W] = {
+      Var(z) { s: Var[W] => '{
+          ${
+            foldRaw[Expr[A]]((a: Expr[A]) => '{
+              ${ s.update(f(s.get, a)) }
+            }, stream)
+          }
+          ${ s.get }
+        }
+      }
+    }
 
      private def foldRaw[A](consumer: A => Expr[Unit], stream: StagedStream[A]): Expr[Unit] = {
        stream match {
@@ -112,14 +115,14 @@ object Test {
            producer.card match {
              case Many =>
                producer.init(sp => '{
-                 while(~producer.hasNext(sp)) {
-                   ~producer.step(sp, consumer)
+                 while(${producer.hasNext(sp)}) {
+                   ${producer.step(sp, consumer)}
                  }
                })
              case AtMost1 =>
                producer.init(sp => '{
-                 if (~producer.hasNext(sp)) {
-                   ~producer.step(sp, consumer)
+                 if (${producer.hasNext(sp)}) {
+                   ${producer.step(sp, consumer)}
                  }
                })
            }
@@ -137,7 +140,7 @@ object Test {
       * @return   a new stream resulting from applying `mapRaw` and threading the element of the first stream downstream.
       */
     def map[B : Type](f: (Expr[A] => Expr[B])): Stream[B] = {
-      Stream(mapRaw[Expr[A], Expr[B]](a => k => '{ ~k(f(a)) }, stream))
+      Stream(mapRaw[Expr[A], Expr[B]](a => k => k(f(a)), stream))
     }
 
     /** Handles generically the mapping of elements from one producer to another.
@@ -299,15 +302,15 @@ object Test {
         def step(st: St, k: (((Var[Int], A)) => Expr[Unit])): Expr[Unit] = {
           val (counter, currentState) = st
           producer.step(currentState, el => '{
-            ~k((counter, el))
+            ${k((counter, el))}
           })
         }
 
         def hasNext(st: St): Expr[Boolean] = {
           val (counter, currentState) = st
           producer.card match {
-            case Many => '{ ~counter.get > 0 && ~producer.hasNext(currentState) }
-            case AtMost1 => '{ ~producer.hasNext(currentState) }
+            case Many => '{ ${counter.get} > 0 && ${producer.hasNext(currentState)} }
+            case AtMost1 => producer.hasNext(currentState)
           }
         }
       }
@@ -329,8 +332,8 @@ object Test {
           // Map an enhanced stream to a stream that produces the elements. Before
           // invoking the continuation for the element, "use" the variable accordingly.
           mapRaw[(Var[Int], A), A]((t: (Var[Int], A)) => k => '{
-            ~t._1.update('{~t._1.get - 1})
-            ~k(t._2)
+            ${t._1.update('{${t._1.get} - 1})}
+            ${k(t._2)}
           }, enhancedStream)
         }
         case nested: Nested[A, bt] => {
@@ -340,9 +343,9 @@ object Test {
             // Before invoking the continuation for the element, "use" the variable accordingly.
             // In contrast to the linear case, the variable is initialized in the originating stream.
             mapRaw[A, A]((el => k => '{
-              ~t._1.update('{~t._1.get - 1})
-              ~k(el)
-            }), addTerminationCondition(b => '{ ~t._1.get > 0 && ~b}, nested.nestedf(t._2)))
+              ${t._1.update('{${t._1.get} - 1})}
+              ${k(el)}
+            }), addTerminationCondition(b => '{ ${t._1.get} > 0 && $b}, nested.nestedf(t._2)))
           })
         }
       }
@@ -361,7 +364,7 @@ object Test {
           pushLinear[A = Expr[A], C = B](producer1, producer2, nestf2)
 
         case (Nested(producer1, nestf1), Linear(producer2)) =>
-          mapRaw[(B, Expr[A]), (Expr[A], B)]((t => k => '{ ~k((t._2, t._1)) }), pushLinear[A = B, C = Expr[A]](producer2, producer1, nestf1))
+          mapRaw[(B, Expr[A]), (Expr[A], B)]((t => k => '{ ${k((t._2, t._1))} }), pushLinear[A = B, C = Expr[A]](producer2, producer1, nestf1))
 
         case (Nested(producer1, nestf1), Nested(producer2, nestf2)) =>
           zipRaw[A, B](Linear(makeLinear(stream1)), stream2)
@@ -442,27 +445,27 @@ object Test {
               case Linear(producer) =>
                 producer.card match {
                   case AtMost1 => producer.init(st => '{
-                    if(~producer.hasNext(st)) {
-                      ~producer.step(st, k)
+                    if(${producer.hasNext(st)}) {
+                      ${producer.step(st, k)}
                     }
                     else {
-                      val f = ~nadv.get
+                      val f = ${nadv.get}
                       f(())
                     }
                   })
                   case Many => producer.init(st => '{
-                    val oldnadv: Unit => Unit = ~nadv.get
+                    val oldnadv: Unit => Unit = ${nadv.get}
                     val adv1: Unit => Unit = { _: Unit => {
-                      if(~producer.hasNext(st)) {
-                        ~producer.step(st, k)
+                      if(${producer.hasNext(st)}) {
+                        ${producer.step(st, k)}
                       }
                       else {
-                        ~nadv.update('{oldnadv})
+                        ${nadv.update('oldnadv)}
                         oldnadv(())
                       }
                     }}
 
-                    ~nadv.update('{adv1})
+                    ${nadv.update('adv1)}
                     adv1(())
                   })
                 }
@@ -486,17 +489,17 @@ object Test {
 
                         // Code generation of the `adv` function
                         def adv: Unit => Unit = { _ =>
-                          ~hasNext.update(producer.hasNext(st))
-                          if(~hasNext.get) {
-                            ~producer.step(st, el => {
+                          ${hasNext.update(producer.hasNext(st))}
+                          if(${hasNext.get}) {
+                            ${producer.step(st, el => {
                               makeAdvanceFunction[Expr[A]](nadv, (a => curr.update(a)), nestedf(el))
-                            })
+                            })}
                           }
                         }
 
-                        ~nadv.update('{adv})
+                        ${nadv.update('adv)}
                         adv(())
-                        ~k((hasNext, curr, nadv))
+                        ${k((hasNext, curr, nadv))}
                      }}
                   }}
                 }})
@@ -505,10 +508,10 @@ object Test {
             def step(st: St, k: Expr[A] => Expr[Unit]): Expr[Unit] = {
               val (flag, current, nadv) = st
               '{
-                var el = ~current.get
-                val f: Unit => Unit = ~nadv.get
+                var el = ${current.get}
+                val f: Unit => Unit = ${nadv.get}
                 f(())
-                ~k('(el))
+                ${k('el)}
               }
 
             }
@@ -529,20 +532,20 @@ object Test {
         val card: Cardinality = Many
 
         def init(k: St => Expr[Unit]): Expr[Unit] = {
-          producer.init(s1 => '{ ~nestedProducer.init(s2 =>
-            Var('{ ~producer.hasNext(s1) }) { flag =>
+          producer.init(s1 => '{ ${nestedProducer.init(s2 =>
+            Var(producer.hasNext(s1)) { flag =>
               k((flag, s1, s2))
-            })})
+            })}})
         }
 
         def step(st: St, k: ((Var[Boolean], producer.St, B)) => Expr[Unit]): Expr[Unit] = {
           val (flag, s1, s2) = st
-          nestedProducer.step(s2, b => '{ ~k((flag, s1, b)) })
+          nestedProducer.step(s2, b => '{ ${k((flag, s1, b))} })
         }
 
         def hasNext(st: St): Expr[Boolean] = {
           val (flag, s1, s2) = st
-          '{ ~flag.get && ~nestedProducer.hasNext(s2) }
+          '{ ${flag.get} && ${nestedProducer.hasNext(s2)} }
         }
       }
 
@@ -550,9 +553,9 @@ object Test {
         val (flag, s1, b) = t
 
         mapRaw[C, (A, C)]((c => k => '{
-          ~producer.step(s1, a => '{ ~k((a, c)) })
-          ~flag.update(producer.hasNext(s1))
-        }), addTerminationCondition((b_flag: Expr[Boolean]) => '{ ~flag.get && ~b_flag }, nestedf(b)))
+          ${producer.step(s1, a => '{ ${k((a, c))} })}
+          ${flag.update(producer.hasNext(s1))}
+        }), addTerminationCondition((b_flag: Expr[Boolean]) => '{ ${flag.get} && $b_flag }, nestedf(b)))
       })
     }
 
@@ -564,17 +567,17 @@ object Test {
         val card: Cardinality = Many
 
         def init(k: St => Expr[Unit]): Expr[Unit] = {
-          producer1.init(s1 => '{ ~producer2.init(s2 => '{ ~k((s1, s2)) })})
+          producer1.init(s1 => producer2.init(s2 => k((s1, s2)) ))
         }
 
         def step(st: St, k: ((A, B)) => Expr[Unit]): Expr[Unit] = {
           val (s1, s2) = st
-          producer1.step(s1, el1 => '{ ~producer2.step(s2, el2 => '{ ~k((el1, el2)) })})
+          producer1.step(s1, el1 => producer2.step(s2, el2 => k((el1, el2)) ))
         }
 
         def hasNext(st: St): Expr[Boolean] = {
           val (s1, s2) = st
-          '{ ~producer1.hasNext(s1) && ~producer2.hasNext(s2) }
+          '{ ${producer1.hasNext(s1)} && ${producer2.hasNext(s2)} }
         }
       }
     }
@@ -582,7 +585,7 @@ object Test {
     /** zip **/
     def zip[B: Type, C: Type](f: (Expr[A] => Expr[B] => Expr[C]), stream2: Stream[B]): Stream[C] = {
       val Stream(stream_b) = stream2
-      Stream(mapRaw[(Expr[A], Expr[B]), Expr[C]]((t => k => '{ ~k(f(t._1)(t._2)) }), zipRaw[A, Expr[B]](stream, stream_b)))
+      Stream(mapRaw[(Expr[A], Expr[B]), Expr[C]]((t => k => k(f(t._1)(t._2))), zipRaw[A, Expr[B]](stream, stream_b)))
     }
   }
 
@@ -594,7 +597,7 @@ object Test {
         val card = Many
 
         def init(k: St => Expr[Unit]): Expr[Unit] = {
-          Var('{(~arr).length}) { n =>
+          Var('{($arr).length}) { n =>
             Var(0.toExpr){ i =>
               k((i, n, arr))
             }
@@ -604,16 +607,16 @@ object Test {
         def step(st: St, k: (Expr[A] => Expr[Unit])): Expr[Unit] = {
           val (i, _, arr) = st
           '{
-              val el = (~arr).apply(~i.get)
-              ~i.update('{ ~i.get + 1 })
-              ~k('(el))
+              val el = ($arr).apply(${i.get})
+              ${i.update('{ ${i.get} + 1 })}
+              ${k('el)}
           }
         }
 
         def hasNext(st: St): Expr[Boolean] =  {
           val (i, n, _) = st
           '{
-              (~i.get < ~n.get)
+              (${i.get} < ${n.get})
           }
         }
       }
@@ -624,53 +627,53 @@ object Test {
 
   def test1() = Stream
     .of('{Array(1, 2, 3)})
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test2() = Stream
     .of('{Array(1, 2, 3)})
-    .map((a: Expr[Int]) => '{ ~a * 2 })
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .map((a: Expr[Int]) => '{ $a * 2 })
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test3() = Stream
     .of('{Array(1, 2, 3)})
-    .flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ ~d * ~dp }))
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ $d * $dp }))
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test4() = Stream
     .of('{Array(1, 2, 3)})
-    .filter((d: Expr[Int]) => '{ ~d % 2 == 0 })
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .filter((d: Expr[Int]) => '{ $d % 2 == 0 })
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test5() = Stream
     .of('{Array(1, 2, 3)})
     .take('{2})
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test6() = Stream
     .of('{Array(1, 1, 1)})
     .flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).take('{2}))
     .take('{5})
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test7() = Stream
     .of('{Array(1, 2, 3)})
-    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ ~a + ~b }), Stream.of('{Array(1, 2, 3)}))
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ $a + $b }), Stream.of('{Array(1, 2, 3)}))
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test8() = Stream
     .of('{Array(1, 2, 3)})
-    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ ~a + ~b }), Stream.of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ ~d + ~dp })))
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ $a + $b }), Stream.of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ $d + $dp })))
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test9() = Stream
-    .of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ ~d + ~dp }))
-    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ ~a + ~b }), Stream.of('{Array(1, 2, 3)}) )
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ $d + $dp }))
+    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ $a + $b }), Stream.of('{Array(1, 2, 3)}) )
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def test10() = Stream
-    .of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ ~d + ~dp }))
-    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ ~a + ~b }), Stream.of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ ~d + ~dp })) )
-    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ ~a + ~b }))
+    .of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ $d + $dp }))
+    .zip(((a : Expr[Int]) => (b : Expr[Int]) => '{ $a + $b }), Stream.of('{Array(1, 2, 3)}).flatMap((d: Expr[Int]) => Stream.of('{Array(1, 2, 3)}).map((dp: Expr[Int]) => '{ $d + $dp })) )
+    .fold('{0}, ((a: Expr[Int], b : Expr[Int]) => '{ $a + $b }))
 
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
diff --git a/tests/run-with-compiler/i3823-b.scala b/tests/run-with-compiler/i3823-b.scala
index cdb5c4eb3bd9..75e35d6ca619 100644
--- a/tests/run-with-compiler/i3823-b.scala
+++ b/tests/run-with-compiler/i3823-b.scala
@@ -3,8 +3,8 @@ import scala.quoted._
 object Test {
   def main(args: Array[String]): Unit = {
     def f[T](x: Expr[T])(implicit t: Type[T]) = '{
-      val z: t.unary_~ = ~x
+      val z: $t = $x
     }
-    println(f('(2))(Type.IntTag).show)
+    println(f('{2})(Type.IntTag).show)
   }
 }
\ No newline at end of file
diff --git a/tests/run-with-compiler/i3823-c.scala b/tests/run-with-compiler/i3823-c.scala
index 976ac729987f..bccae95b5278 100644
--- a/tests/run-with-compiler/i3823-c.scala
+++ b/tests/run-with-compiler/i3823-c.scala
@@ -3,9 +3,9 @@ import scala.quoted._
 object Test {
   def main(args: Array[String]): Unit = {
     def f[T](x: Expr[T])(implicit t: Type[T]) = '{
-      val z = ~x
+      val z = $x
     }
-    println(f('(2))(Type.IntTag).show)
+    println(f('{2})(Type.IntTag).show)
   }
 }
 
diff --git a/tests/run-with-compiler/i3823.scala b/tests/run-with-compiler/i3823.scala
index dc593a1e1715..ad43cc70e6d5 100644
--- a/tests/run-with-compiler/i3823.scala
+++ b/tests/run-with-compiler/i3823.scala
@@ -3,8 +3,8 @@ import scala.quoted._
 object Test {
   def main(args: Array[String]): Unit = {
     def f[T: Type](x: Expr[T])(t: Type[T]) = '{
-      val z: t.unary_~ = ~x
+      val z: $t = $x
     }
-    println(f('(2))('[Int]).show)
+    println(f('{2})('[Int]).show)
   }
 }
\ No newline at end of file
diff --git a/tests/run-with-compiler/i3847-b.scala b/tests/run-with-compiler/i3847-b.scala
index 370322f5f071..dd7cb855caca 100644
--- a/tests/run-with-compiler/i3847-b.scala
+++ b/tests/run-with-compiler/i3847-b.scala
@@ -6,7 +6,7 @@ object Arrays {
   implicit def ArrayIsLiftable[T: Liftable](implicit t: Type[T]): Liftable[Array[List[T]]] = {
     new Liftable[Array[List[T]]] {
       def toExpr(arr: Array[List[T]]): Expr[Array[List[T]]] = '{
-        new Array[List[~t]](~arr.length.toExpr)
+        new Array[List[$t]](${arr.length.toExpr})
         // TODO add elements
       }
     }
@@ -16,7 +16,7 @@ object Arrays {
 object Test {
   def main(args: Array[String]): Unit = {
     import Arrays._
-    implicit val ct: Expr[ClassTag[Int]] = '(ClassTag.Int)
+    implicit val ct: Expr[ClassTag[Int]] = '{ClassTag.Int}
     val arr: Expr[Array[List[Int]]] = Array[List[Int]](List(1, 2, 3)).toExpr
     println(arr.show)
   }
diff --git a/tests/run-with-compiler/i3847.scala b/tests/run-with-compiler/i3847.scala
index 43a3efb5d573..02be34330a9b 100644
--- a/tests/run-with-compiler/i3847.scala
+++ b/tests/run-with-compiler/i3847.scala
@@ -6,7 +6,7 @@ object Arrays {
   implicit def ArrayIsLiftable[T: Liftable](implicit t: Type[T], ct: Expr[ClassTag[T]]): Liftable[Array[T]] = {
     new Liftable[Array[T]] {
       def toExpr(arr: Array[T]): Expr[Array[T]] = '{
-        new Array[~t](~arr.length.toExpr)(~ct)
+        new Array[$t](${arr.length.toExpr})($ct)
         // TODO add elements
       }
     }
@@ -16,7 +16,7 @@ object Arrays {
 object Test {
   def main(args: Array[String]): Unit = {
     import Arrays._
-    implicit val ct: Expr[ClassTag[Int]] = '(ClassTag.Int)
+    implicit val ct: Expr[ClassTag[Int]] = '{ClassTag.Int}
     val arr: Expr[Array[Int]] = Array[Int](1, 2, 3).toExpr
     println(arr.show)
   }
diff --git a/tests/run-with-compiler/i3876-b.scala b/tests/run-with-compiler/i3876-b.scala
index fc89db875075..c252c9d84dfa 100644
--- a/tests/run-with-compiler/i3876-b.scala
+++ b/tests/run-with-compiler/i3876-b.scala
@@ -4,7 +4,7 @@ object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-    val x: Expr[Int] = '(3)
+    val x: Expr[Int] = '{3}
 
     val f2: Expr[Int => Int] = '{
       def f(x: Int): Int = x + x
diff --git a/tests/run-with-compiler/i3876-c.scala b/tests/run-with-compiler/i3876-c.scala
index 6e3b5213f081..061bf3a985f4 100644
--- a/tests/run-with-compiler/i3876-c.scala
+++ b/tests/run-with-compiler/i3876-c.scala
@@ -4,7 +4,7 @@ object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-    val x: Expr[Int] = '(3)
+    val x: Expr[Int] = '{3}
 
     val f3: Expr[Int => Int] = '{
       val f: (x: Int) => Int = x => x + x
diff --git a/tests/run-with-compiler/i3876-d.scala b/tests/run-with-compiler/i3876-d.scala
index c3c2bec7a70a..7629b6a5c349 100644
--- a/tests/run-with-compiler/i3876-d.scala
+++ b/tests/run-with-compiler/i3876-d.scala
@@ -4,7 +4,7 @@ object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-    val x: Expr[Int] = '(3)
+    val x: Expr[Int] = '{3}
 
     val f4: Expr[Int => Int] = '{
       inlineLambda
diff --git a/tests/run-with-compiler/i3876.scala b/tests/run-with-compiler/i3876.scala
index 67324b9518f1..3f1d5363c718 100644
--- a/tests/run-with-compiler/i3876.scala
+++ b/tests/run-with-compiler/i3876.scala
@@ -4,7 +4,7 @@ object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-    val x: Expr[Int] = '(3)
+    val x: Expr[Int] = '{3}
 
     val f: Expr[Int => Int] = '{ (x: Int) => x + x }
     println(f(x).run)
diff --git a/tests/run-with-compiler/i3946.scala b/tests/run-with-compiler/i3946.scala
index 6a3108b2b298..12e129884a3d 100644
--- a/tests/run-with-compiler/i3946.scala
+++ b/tests/run-with-compiler/i3946.scala
@@ -4,7 +4,7 @@ object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-    val u: Expr[Unit] = '()
+    val u: Expr[Unit] = '{}
     println(u.show)
     println(u.run)
   }
diff --git a/tests/run-with-compiler/i3947.scala b/tests/run-with-compiler/i3947.scala
index e498cfe9f618..45d3971f90b8 100644
--- a/tests/run-with-compiler/i3947.scala
+++ b/tests/run-with-compiler/i3947.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947b.scala b/tests/run-with-compiler/i3947b.scala
index ab30d1fd9847..4b4460daf5d4 100644
--- a/tests/run-with-compiler/i3947b.scala
+++ b/tests/run-with-compiler/i3947b.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947b2.scala b/tests/run-with-compiler/i3947b2.scala
index aad8ab6d7dc2..8007f5607f9f 100644
--- a/tests/run-with-compiler/i3947b2.scala
+++ b/tests/run-with-compiler/i3947b2.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947b3.scala b/tests/run-with-compiler/i3947b3.scala
index 0d34734a7aa0..4ba6643491d3 100644
--- a/tests/run-with-compiler/i3947b3.scala
+++ b/tests/run-with-compiler/i3947b3.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947c.scala b/tests/run-with-compiler/i3947c.scala
index 4bb6a829605f..1fed62b8832f 100644
--- a/tests/run-with-compiler/i3947c.scala
+++ b/tests/run-with-compiler/i3947c.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947d.scala b/tests/run-with-compiler/i3947d.scala
index 33466ceccede..fa73e2bd217e 100644
--- a/tests/run-with-compiler/i3947d.scala
+++ b/tests/run-with-compiler/i3947d.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947d2.scala b/tests/run-with-compiler/i3947d2.scala
index cac86cfa42f9..f86a52ad9a37 100644
--- a/tests/run-with-compiler/i3947d2.scala
+++ b/tests/run-with-compiler/i3947d2.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947e.scala b/tests/run-with-compiler/i3947e.scala
index 1a84025cbb32..25f41fe0789a 100644
--- a/tests/run-with-compiler/i3947e.scala
+++ b/tests/run-with-compiler/i3947e.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947f.scala b/tests/run-with-compiler/i3947f.scala
index 67b83d7edcfa..6d1c6239759e 100644
--- a/tests/run-with-compiler/i3947f.scala
+++ b/tests/run-with-compiler/i3947f.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947g.scala b/tests/run-with-compiler/i3947g.scala
index 9132a459d1c3..0d1fa78978f2 100644
--- a/tests/run-with-compiler/i3947g.scala
+++ b/tests/run-with-compiler/i3947g.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947i.scala b/tests/run-with-compiler/i3947i.scala
index ae07aaebfed9..3c0918392cd1 100644
--- a/tests/run-with-compiler/i3947i.scala
+++ b/tests/run-with-compiler/i3947i.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i3947j.scala b/tests/run-with-compiler/i3947j.scala
index 2e4045ac5a6f..c9c2b1dcf6d4 100644
--- a/tests/run-with-compiler/i3947j.scala
+++ b/tests/run-with-compiler/i3947j.scala
@@ -9,7 +9,7 @@ object Test {
 
     def test[T: Type](clazz: java.lang.Class[T]): Unit = {
       val lclazz = clazz.toExpr
-      val name = '{ (~lclazz).getCanonicalName }
+      val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
       println(name.run)
diff --git a/tests/run-with-compiler/i4044a.scala b/tests/run-with-compiler/i4044a.scala
index fc05dbcb8ed9..e8ff3d67979e 100644
--- a/tests/run-with-compiler/i4044a.scala
+++ b/tests/run-with-compiler/i4044a.scala
@@ -3,8 +3,8 @@ import scala.quoted.Toolbox.Default._
 
 class Foo {
   def foo: Unit = {
-    val e: Expr[Int] = '(3)
-    val q = '{ ~( '{ ~e } ) }
+    val e: Expr[Int] = '{3}
+    val q = '{ ${ '{ $e } } }
     println(q.show)
   }
 }
diff --git a/tests/run-with-compiler/i4044b.scala b/tests/run-with-compiler/i4044b.scala
index 66a57073e9ff..e9e474a73934 100644
--- a/tests/run-with-compiler/i4044b.scala
+++ b/tests/run-with-compiler/i4044b.scala
@@ -9,20 +9,20 @@ sealed abstract class VarRef[T] {
 
 object VarRef {
   def apply[T: Type, U: Type](init: Expr[T])(body: VarRef[T] => Expr[U]): Expr[U] = '{
-    var x = ~init
-    ~body(
+    var x = $init
+    ${body(
       new VarRef {
-        def update(e: Expr[T]): Expr[Unit] = '{ x = ~e }
-        def expr: Expr[T] = '(x)
+        def update(e: Expr[T]): Expr[Unit] = '{ x = $e }
+        def expr: Expr[T] = 'x
       }
-    )
+    )}
   }
 
 }
 
 object Test {
   def main(args: Array[String]): Unit = {
-    val q = VarRef('(4))(varRef => '{ ~varRef.update('(3)); ~varRef.expr })
+    val q = VarRef('{4})(varRef => '{ ${varRef.update('{3})}; ${varRef.expr} })
     println(q.show)
   }
 }
diff --git a/tests/run-with-compiler/i4044c.scala b/tests/run-with-compiler/i4044c.scala
index 0071624d7ece..5a38da369e6a 100644
--- a/tests/run-with-compiler/i4044c.scala
+++ b/tests/run-with-compiler/i4044c.scala
@@ -3,7 +3,7 @@ import scala.quoted.Toolbox.Default._
 
 class Foo {
   def foo: Unit = {
-    val q = '{ ~( '{ ~( '{ 5 } ) } ) }
+    val q = '{ ${ '{ ${ '{ 5 } } } } }
     println(q.show)
   }
 }
diff --git a/tests/run-with-compiler/i4044d.scala b/tests/run-with-compiler/i4044d.scala
index b1afb942253e..05e177a80f89 100644
--- a/tests/run-with-compiler/i4044d.scala
+++ b/tests/run-with-compiler/i4044d.scala
@@ -3,13 +3,13 @@ import scala.quoted.Toolbox.Default._
 
 class Foo {
   def foo: Unit = {
-    val a: Expr[Int] = '(3)
+    val a: Expr[Int] = '{3}
     val q: Expr[Int] = '{
       val b = 3
-      ~{
+      ${
         println("evaluating inner quote")
         '{
-          b + ~a
+          b + $a
         }
       }
     }
diff --git a/tests/run-with-compiler/i4044e.scala b/tests/run-with-compiler/i4044e.scala
index 8e7ea90d6e67..05c82bed26ba 100644
--- a/tests/run-with-compiler/i4044e.scala
+++ b/tests/run-with-compiler/i4044e.scala
@@ -3,10 +3,10 @@ import scala.quoted.Toolbox.Default._
 
 class Foo {
   def foo: Unit = {
-    val e: Expr[Int] = '(3)
-    val f: Expr[Int] = '(5)
+    val e: Expr[Int] = '{3}
+    val f: Expr[Int] = '{5}
     val t: Type[Int] = '[Int]
-    val q = '{ ~( '{ (~e + ~f).asInstanceOf[~t] } ) }
+    val q = '{ ${ '{ ($e + $f).asInstanceOf[$t] } } }
     println(q.show)
   }
 }
diff --git a/tests/run-with-compiler/i4044f.scala b/tests/run-with-compiler/i4044f.scala
index 59330937e8fb..2b63f6d2bd12 100644
--- a/tests/run-with-compiler/i4044f.scala
+++ b/tests/run-with-compiler/i4044f.scala
@@ -3,15 +3,15 @@ import scala.quoted.Toolbox.Default._
 
 class Foo {
   def foo: Unit = {
-    val e: Expr[Int] = '(3)
-    val f: Expr[Int] = '(5)
-    def foo(x: Expr[Int], y: Expr[Int]): Expr[Int] = '{ ~x + ~y }
+    val e: Expr[Int] = '{3}
+    val f: Expr[Int] = '{5}
+    def foo(x: Expr[Int], y: Expr[Int]): Expr[Int] = '{ $x + $y }
     val q = '{
-      val e1 = ~e
-      val f1 = ~f
-      ~{
-        val u = '(2)
-        foo('{e1 + ~u}, '(f1))
+      val e1 = $e
+      val f1 = $f
+      ${
+        val u = '{2}
+        foo('{e1 + $u}, '{f1})
       }
     }
     println(q.show)
diff --git a/tests/run-with-compiler/i4350.scala b/tests/run-with-compiler/i4350.scala
index 6edf550a44bf..1521e1b301ae 100644
--- a/tests/run-with-compiler/i4350.scala
+++ b/tests/run-with-compiler/i4350.scala
@@ -3,7 +3,7 @@ import scala.quoted.Toolbox.Default._
 import scala.quoted.Type
 
 class Foo[T: Type] {
-  def q = '((null: Any).asInstanceOf[T])
+  def q = '{(null: Any).asInstanceOf[T]}
 }
 
 object Test {
diff --git a/tests/run-with-compiler/i4591.scala b/tests/run-with-compiler/i4591.scala
index cfad307c2bfc..6ae5ac944dac 100644
--- a/tests/run-with-compiler/i4591.scala
+++ b/tests/run-with-compiler/i4591.scala
@@ -4,12 +4,12 @@ import scala.quoted._
 object Test {
 
   def foo[T: Type](init: Expr[T]): Expr[Unit] = '{
-    var x = ~init
+    var x = $init
     println(x)
   }
 
   def main(args: Array[String]): Unit = {
-    foo('(Option(9))).run
+    foo('{Option(9)}).run
   }
 
 }
diff --git a/tests/run-with-compiler/i5144.scala b/tests/run-with-compiler/i5144.scala
index 122e060aa754..316e7c6ca055 100644
--- a/tests/run-with-compiler/i5144.scala
+++ b/tests/run-with-compiler/i5144.scala
@@ -3,10 +3,10 @@ import scala.quoted._
 object Test {
   implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-  def eval1(ff: Expr[Int => Int]): Expr[Int] = '((~ff)(42))
+  def eval1(ff: Expr[Int => Int]): Expr[Int] = '{$ff(42)}
 
   def peval1(): Expr[Unit] = '{
-    def f(x: Int): Int = ~eval1('(f))
+    def f(x: Int): Int = ${eval1('f)}
   }
 
   def main(args: Array[String]): Unit = {
diff --git a/tests/run-with-compiler/i5144b.scala b/tests/run-with-compiler/i5144b.scala
index f616374decb8..1ba60137ebd1 100644
--- a/tests/run-with-compiler/i5144b.scala
+++ b/tests/run-with-compiler/i5144b.scala
@@ -3,10 +3,10 @@ import scala.quoted._
 object Test {
   implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-  def eval1(ff: Expr[Int => Int]): Expr[Int] = ff('(42))
+  def eval1(ff: Expr[Int => Int]): Expr[Int] = ff('{42})
 
   def peval1(): Expr[Unit] = '{
-    def f(x: Int): Int = ~eval1('(f))
+    def f(x: Int): Int = ${eval1('f)}
   }
 
   def main(args: Array[String]): Unit = {
diff --git a/tests/run-with-compiler/i5152.scala b/tests/run-with-compiler/i5152.scala
index f115bc609974..218ffff8e2ab 100644
--- a/tests/run-with-compiler/i5152.scala
+++ b/tests/run-with-compiler/i5152.scala
@@ -3,10 +3,10 @@ import scala.quoted._
 object Test {
   implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-  def eval1(ff: Expr[Int => Int]): Expr[Int => Int] = '(identity)
+  def eval1(ff: Expr[Int => Int]): Expr[Int => Int] = '{identity}
 
   def peval1(): Expr[Unit] = '{
-    lazy val f: Int => Int = ~eval1('((y: Int) => f(y)))
+    lazy val f: Int => Int = ${eval1('{(y: Int) => f(y)})}
   }
 
   def main(args: Array[String]): Unit = {
diff --git a/tests/run-with-compiler/i5247.scala b/tests/run-with-compiler/i5247.scala
index 5a8d02ef3681..38e04d42aa12 100644
--- a/tests/run-with-compiler/i5247.scala
+++ b/tests/run-with-compiler/i5247.scala
@@ -7,10 +7,10 @@ object Test {
   }
   def foo[H : Type]: Expr[H] = {
     val t = '[H]
-    '{ null.asInstanceOf[~t] }
+    '{ null.asInstanceOf[$t] }
   }
   def bar[H : Type]: Expr[List[H]] = {
     val t = '[List[H]]
-    '{ null.asInstanceOf[~t] }
+    '{ null.asInstanceOf[$t] }
   }
 }
diff --git a/tests/run-with-compiler/quote-ackermann-1.scala b/tests/run-with-compiler/quote-ackermann-1.scala
index 0e45816631e7..e22d07173014 100644
--- a/tests/run-with-compiler/quote-ackermann-1.scala
+++ b/tests/run-with-compiler/quote-ackermann-1.scala
@@ -15,7 +15,7 @@ object Test {
   def ackermann(m: Int): Expr[Int => Int] = {
     if (m == 0) '{ n => n + 1 }
     else '{ n =>
-      def `ackermann(m-1)`(n: Int): Int = ~ackermann(m - 1)('(n)) // Expr[Int => Int] applied to Expr[Int]
+      def `ackermann(m-1)`(n: Int): Int = ${ackermann(m - 1)('n)} // Expr[Int => Int] applied to Expr[Int]
       def `ackermann(m)`(n: Int): Int =
         if (n == 0) `ackermann(m-1)`(1) else `ackermann(m-1)`(`ackermann(m)`(n - 1))
       `ackermann(m)`(n)
diff --git a/tests/run-with-compiler/quote-fun-app-1.scala b/tests/run-with-compiler/quote-fun-app-1.scala
index cd61c6d95b65..890de0d14987 100644
--- a/tests/run-with-compiler/quote-fun-app-1.scala
+++ b/tests/run-with-compiler/quote-fun-app-1.scala
@@ -10,8 +10,8 @@ object Test {
     println(f(43))
   }
 
-  def f1: Expr[Int => Int] = '{ n => ~f2('(n)) }
-  def f2: Expr[Int => Int] = '{ n => ~f3('(n)) }
-  def f3: Expr[Int => Int] = '{ n => ~f4('(n)) }
+  def f1: Expr[Int => Int] = '{ n => ${f2('n)} }
+  def f2: Expr[Int => Int] = '{ n => ${f3('n)} }
+  def f3: Expr[Int => Int] = '{ n => ${f4('n)} }
   def f4: Expr[Int => Int] = '{ n => n }
 }
diff --git a/tests/run-with-compiler/quote-function-applied-to.scala b/tests/run-with-compiler/quote-function-applied-to.scala
index faac3dfec8a6..fa381cea8eff 100644
--- a/tests/run-with-compiler/quote-function-applied-to.scala
+++ b/tests/run-with-compiler/quote-function-applied-to.scala
@@ -4,28 +4,28 @@ import scala.quoted.Toolbox.Default._
 object Test {
   def main(args: Array[String]): Unit = {
     println(('{ () => x(0) }).apply().show)
-    println(('{ (x1: Int) => x1 }).apply('(x(1))).show)
-    println(('{ (x1: Int, x2: Int) => x1 + x2 }).apply('(x(1)), '(x(2))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int) => x1 + x2 + x3 }).apply('(x(1)), '(x(2)), '(x(3))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int) => x1 + x2 + x3 + x4 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int) => x1 + x2 + x3 + x4 + x5 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int) => x1 + x2 + x3 + x4 + x5 + x6 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16)), '(x(17))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16)), '(x(17)), '(x(18))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16)), '(x(17)), '(x(18)), '(x(19))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16)), '(x(17)), '(x(18)), '(x(19)), '(x(20))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16)), '(x(17)), '(x(18)), '(x(19)), '(x(20)), '(x(21))).show)
-    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int, x22: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 }).apply('(x(1)), '(x(2)), '(x(3)), '(x(4)), '(x(5)), '(x(6)), '(x(7)), '(x(8)), '(x(9)), '(x(10)), '(x(11)), '(x(12)), '(x(13)), '(x(14)), '(x(15)), '(x(16)), '(x(17)), '(x(18)), '(x(19)), '(x(20)), '(x(21)), '(x(22))).show)
+    println(('{ (x1: Int) => x1 }).apply('{x(1)}).show)
+    println(('{ (x1: Int, x2: Int) => x1 + x2 }).apply('{x(1)}, '{x(2)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int) => x1 + x2 + x3 }).apply('{x(1)}, '{x(2)}, '{x(3)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int) => x1 + x2 + x3 + x4 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int) => x1 + x2 + x3 + x4 + x5 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int) => x1 + x2 + x3 + x4 + x5 + x6 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}, '{x(17)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}, '{x(17)}, '{x(18)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}, '{x(17)}, '{x(18)}, '{x(19)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}, '{x(17)}, '{x(18)}, '{x(19)}, '{x(20)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}, '{x(17)}, '{x(18)}, '{x(19)}, '{x(20)}, '{x(21)}).show)
+    println(('{ (x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int, x22: Int) => x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 }).apply('{x(1)}, '{x(2)}, '{x(3)}, '{x(4)}, '{x(5)}, '{x(6)}, '{x(7)}, '{x(8)}, '{x(9)}, '{x(10)}, '{x(11)}, '{x(12)}, '{x(13)}, '{x(14)}, '{x(15)}, '{x(16)}, '{x(17)}, '{x(18)}, '{x(19)}, '{x(20)}, '{x(21)}, '{x(22)}).show)
   }
 
   def x(i: Int): Int = i
diff --git a/tests/run-with-compiler/quote-impure-by-name/quoted_1.scala b/tests/run-with-compiler/quote-impure-by-name/quoted_1.scala
index 4eb0b86d8541..550e34b96b04 100644
--- a/tests/run-with-compiler/quote-impure-by-name/quoted_1.scala
+++ b/tests/run-with-compiler/quote-impure-by-name/quoted_1.scala
@@ -9,10 +9,10 @@ object Index {
 
   implicit def zero[K, T]: Index[K, (K, T)] = new Index("0")
 
-  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ~succImpl('(prev))('[K], '[H], '[T])
+  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ${ succImpl('prev)('[K], '[H], '[T]) }
 
   def succImpl[K, H, T](prev: Expr[Index[K, T]])(implicit k: Type[K], h: Type[H], t: Type[T]): Expr[Index[K, (H, T)]] = {
     val value = s"1 + {${prev.show}}"
-    '(new Index(~value.toExpr))
+    '{new Index(${value.toExpr})}
   }
 }
\ No newline at end of file
diff --git a/tests/run-with-compiler/quote-inline-function/quoted_1.scala b/tests/run-with-compiler/quote-inline-function/quoted_1.scala
index a982c7eb3e16..1a17e4f114e5 100644
--- a/tests/run-with-compiler/quote-inline-function/quoted_1.scala
+++ b/tests/run-with-compiler/quote-inline-function/quoted_1.scala
@@ -4,19 +4,19 @@ import scala.quoted.Toolbox.Default._
 
 object Macros {
 
-  inline def foreach1(start: Int, end: Int, f: Int => Unit): String = ~impl('(start), '(end), '(f))
-  inline def foreach2(start: Int, end: Int, f: => Int => Unit): String = ~impl('(start), '(end), '(f))
+  inline def foreach1(start: Int, end: Int, f: Int => Unit): String = ${impl('start, 'end, 'f)}
+  inline def foreach2(start: Int, end: Int, f: => Int => Unit): String = ${impl('start, 'end, 'f)}
 
   def impl(start: Expr[Int], end: Expr[Int], f: Expr[Int => Unit]): Expr[String] = {
     val res = '{
-      var i = ~start
-      val j = ~end
+      var i = $start
+      val j = $end
       while (i < j) {
-        ~f.apply('(i))
+        ${f.apply('i)}
         i += 1
       }
       do {
-        ~f.apply('(i))
+        ${f.apply('i)}
         i += 1
       } while (i < j)
     }
diff --git a/tests/run-with-compiler/quote-lambda.scala b/tests/run-with-compiler/quote-lambda.scala
index 91a871ab1bc8..c904c3676a61 100644
--- a/tests/run-with-compiler/quote-lambda.scala
+++ b/tests/run-with-compiler/quote-lambda.scala
@@ -2,6 +2,6 @@ import scala.quoted._
 
 object Test {
   def main(args: Array[String]): Unit = {
-    '{ (x: Int) => ~('(x)) }
+    '{ (x: Int) => ${'x} }
   }
 }
diff --git a/tests/run-with-compiler/quote-lib.scala b/tests/run-with-compiler/quote-lib.scala
index 08178e3d58f8..c595684fb7f7 100644
--- a/tests/run-with-compiler/quote-lib.scala
+++ b/tests/run-with-compiler/quote-lib.scala
@@ -13,14 +13,14 @@ object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
-    val liftedUnit: Expr[Unit] = '()
+    val liftedUnit: Expr[Unit] = '{}
 
-    letVal('(1))(a => '{ ~a + 1 }).show
-    letLazyVal('(1))(a => '{ ~a + 1 }).show
-    letDef('(1))(a => '{ ~a + 1 }).show
+    letVal('{1})(a => '{ $a + 1 }).show
+    letLazyVal('{1})(a => '{ $a + 1 }).show
+    letDef('{1})(a => '{ $a + 1 }).show
 
-    liftedWhile('(true))('{ println(1) }).show
-    liftedDoWhile('{ println(1) })('(true)).show
+    liftedWhile('{true})('{ println(1) }).show
+    liftedDoWhile('{ println(1) })('{true}).show
 
     val t1: Expr[Tuple1[Int]] = Tuple1(4).toExpr
     val t2: Expr[(Int, Int)] = (2, 3).toExpr
@@ -54,46 +54,46 @@ package liftable {
 
   object Units {
     implicit def UnitIsLiftable: Liftable[Unit] = new Liftable[Unit] {
-      def toExpr(x: Unit): Expr[Unit] = '()
+      def toExpr(x: Unit): Expr[Unit] = '{}
     }
   }
 
   object Lets {
     def letVal[T, U: Type](expr: Expr[T])(body: Expr[T] => Expr[U])(implicit t: Type[T]): Expr[U] =
-      '{ val letVal: ~t = ~expr; ~body('(letVal)) }
+      '{ val letVal: $t = $expr; ${ body('letVal) } }
     def letLazyVal[T, U: Type](expr: Expr[T])(body: Expr[T] => Expr[U])(implicit t: Type[T]): Expr[U] =
-      '{ lazy val letLazyVal: ~t = ~expr; ~body('(letLazyVal)) }
+      '{ lazy val letLazyVal: $t = $expr; ${ body('letLazyVal) } }
     def letDef[T, U: Type](expr: Expr[T])(body: Expr[T] => Expr[U])(implicit t: Type[T]): Expr[U] =
-      '{ def letDef: ~t = ~expr; ~body('(letDef)) }
+      '{ def letDef: $t = $expr; ${ body('letDef) } }
   }
 
   object Loops {
-    def liftedWhile(cond: Expr[Boolean])(body: Expr[Unit]): Expr[Unit] = '{ while (~cond) ~body }
-    def liftedDoWhile(body: Expr[Unit])(cond: Expr[Boolean]): Expr[Unit] = '{ do ~body while (~cond) }
+    def liftedWhile(cond: Expr[Boolean])(body: Expr[Unit]): Expr[Unit] = '{ while ($cond) $body }
+    def liftedDoWhile(body: Expr[Unit])(cond: Expr[Boolean]): Expr[Unit] = '{ do $body while ($cond) }
   }
 
   object Tuples {
 
     implicit def Tuple1IsLiftable[T1: Liftable](implicit t1: Type[T1]): Liftable[Tuple1[T1]] = new Liftable[Tuple1[T1]] {
       def toExpr(x: Tuple1[T1]): Expr[Tuple1[T1]] =
-        '{ Tuple1[~t1](~x._1.toExpr) }
+        '{ Tuple1[$t1](${ x._1.toExpr}) }
     }
 
     implicit def Tuple2IsLiftable[T1: Liftable, T2: Liftable](implicit t1: Type[T1], t2: Type[T2]): Liftable[(T1, T2)] = new Liftable[(T1, T2)] {
       def toExpr(x: (T1, T2)): Expr[(T1, T2)] =
-        '{ Tuple2[~t1, ~t2](~x._1.toExpr, ~x._2.toExpr) }
+        '{ Tuple2[$t1, $t2](${x._1.toExpr}, ${x._2.toExpr}) }
 
     }
 
     implicit def Tuple3IsLiftable[T1: Liftable, T2: Liftable, T3: Liftable](implicit t1: Type[T1], t2: Type[T2], t3: Type[T3]): Liftable[(T1, T2, T3)] = new Liftable[(T1, T2, T3)] {
       def toExpr(x: (T1, T2, T3)): Expr[(T1, T2, T3)] =
-        '{ Tuple3[~t1, ~t2, ~t3](~x._1.toExpr, ~x._2.toExpr, ~x._3.toExpr) }
+        '{ Tuple3[$t1, $t2, $t3](${x._1.toExpr}, ${x._2.toExpr}, ${x._3.toExpr}) }
 
     }
 
     implicit def Tuple4IsLiftable[T1: Liftable, T2: Liftable, T3: Liftable, T4: Liftable](implicit t1: Type[T1], t2: Type[T2], t3: Type[T3], t4: Type[T4]): Liftable[(T1, T2, T3, T4)] = new Liftable[(T1, T2, T3, T4)] {
       def toExpr(x: (T1, T2, T3, T4)): Expr[(T1, T2, T3, T4)] =
-        '{ Tuple4[~t1, ~t2, ~t3, ~t4](~x._1.toExpr, ~x._2.toExpr, ~x._3.toExpr, ~x._4.toExpr) }
+        '{ Tuple4[$t1, $t2, $t3, $t4](${x._1.toExpr}, ${x._2.toExpr}, ${x._3.toExpr}, ${x._4.toExpr}) }
     }
 
     // TODO more tuples
@@ -104,32 +104,32 @@ package liftable {
   object Lists {
     implicit def ListIsLiftable[T: Liftable](implicit t: Type[T]): Liftable[List[T]] = new Liftable[List[T]] {
       def toExpr(x: List[T]): Expr[List[T]] = x match {
-        case x :: xs  => '{ (~xs.toExpr).::[~t](~x.toExpr) }
-        case Nil => '{ Nil: List[~t] }
+        case x :: xs  => '{ (${xs.toExpr}).::[$t](${x.toExpr}) }
+        case Nil => '{ Nil: List[$t] }
       }
     }
 
     implicit class LiftedOps[T: Liftable](list: Expr[List[T]])(implicit t: Type[T]) {
       def foldLeft[U](acc: Expr[U])(f: Expr[(U, T) => U])(implicit u: Type[U]): Expr[U] =
-        '{ (~list).foldLeft[~u](~acc)(~f) }
+        '{ ($list).foldLeft[$u]($acc)($f) }
       def foreach(f: Expr[T => Unit]): Expr[Unit] =
-        '{ (~list).foreach(~f) }
+        '{ ($list).foreach($f) }
     }
 
     implicit class UnrolledOps[T: Liftable](list: List[T])(implicit t: Type[T]) {
       def unrolledFoldLeft[U](acc: Expr[U])(f: Expr[(U, T) => U])(implicit u: Type[U]): Expr[U] = list match {
-        case x :: xs => xs.unrolledFoldLeft('{ (~f).apply(~acc, ~x.toExpr) })(f)
+        case x :: xs => xs.unrolledFoldLeft('{ ($f).apply($acc, ${x.toExpr}) })(f)
         case Nil => acc
       }
        def unrolledForeach(f: Expr[T => Unit]): Expr[Unit] = list match {
-         case x :: xs => '{ (~f).apply(~x.toExpr); ~xs.unrolledForeach(f) }
-         case Nil => '()
+         case x :: xs => '{ ($f).apply(${x.toExpr}); ${ xs.unrolledForeach(f) } }
+         case Nil => '{}
        }
     }
 
     object Arrays {
       implicit def ArrayIsLiftable[T: Liftable](implicit t: Type[T], ct: Expr[ClassTag[T]]): Liftable[Array[T]] = new Liftable[Array[T]] {
-        def toExpr(arr: Array[T]): Expr[Array[T]] = '{ new Array[~t](~arr.length.toExpr)(~ct) }
+        def toExpr(arr: Array[T]): Expr[Array[T]] = '{ new Array[$t](${arr.length.toExpr})($ct) }
       }
     }
 
diff --git a/tests/run-with-compiler/quote-nested-1.scala b/tests/run-with-compiler/quote-nested-1.scala
index 5adc94754bea..9233eb750db1 100644
--- a/tests/run-with-compiler/quote-nested-1.scala
+++ b/tests/run-with-compiler/quote-nested-1.scala
@@ -3,7 +3,7 @@ import scala.quoted.Toolbox.Default._
 
 object Test {
   def main(args: Array[String]): Unit = {
-    val q = '{ '(3) }
+    val q = '{ '{3} }
     println(q.show)
   }
 }
diff --git a/tests/run-with-compiler/quote-nested-2.scala b/tests/run-with-compiler/quote-nested-2.scala
index da69d4cf707c..eb141e0025e5 100644
--- a/tests/run-with-compiler/quote-nested-2.scala
+++ b/tests/run-with-compiler/quote-nested-2.scala
@@ -4,8 +4,8 @@ import scala.quoted.Toolbox.Default._
 object Test {
   def main(args: Array[String]): Unit = {
     val q = '{
-      val a = '(4)
-      '(~a)
+      val a = '{4}
+      '{${a}}
     }
 
     println(q.show)
diff --git a/tests/run-with-compiler/quote-nested-3.scala b/tests/run-with-compiler/quote-nested-3.scala
index 02170e2acd0b..de5248a669c8 100644
--- a/tests/run-with-compiler/quote-nested-3.scala
+++ b/tests/run-with-compiler/quote-nested-3.scala
@@ -7,9 +7,9 @@ object Test {
     val q = '{
       type T = String
       val x = "foo"
-      ~{
-        val y = '(x)
-        '{ val z: T = ~y }
+      ${
+        val y = 'x
+        '{ val z: T = $y }
       }
       x
     }
diff --git a/tests/run-with-compiler/quote-nested-5.scala b/tests/run-with-compiler/quote-nested-5.scala
index 902c2ae885b1..22effdaa9026 100644
--- a/tests/run-with-compiler/quote-nested-5.scala
+++ b/tests/run-with-compiler/quote-nested-5.scala
@@ -4,10 +4,10 @@ import scala.quoted.Toolbox.Default._
 object Test {
   def main(args: Array[String]): Unit = {
     val q = '{
-      val a = '(4)
-      ~('{
-        '(~a)
-      })
+      val a = '{4}
+      ${'{
+        '{${a}}
+      }}
 
     }
 
diff --git a/tests/run-with-compiler/quote-owners-2.scala b/tests/run-with-compiler/quote-owners-2.scala
index 78db786a24e6..94a1857cf617 100644
--- a/tests/run-with-compiler/quote-owners-2.scala
+++ b/tests/run-with-compiler/quote-owners-2.scala
@@ -13,8 +13,8 @@ object Test {
 
   def f(t: Type[List[Int]]): Expr[Int] = '{
     def ff: Int = {
-      val a: ~t = {
-        type T = ~t
+      val a: $t = {
+        type T = $t
         val b: T = 3 :: Nil
         b
       }
@@ -23,5 +23,5 @@ object Test {
     ff
   }
 
-  def g[T](a: Type[T]): Type[List[T]] = '[List[~a]]
+  def g[T](a: Type[T]): Type[List[T]] = '[List[$a]]
 }
diff --git a/tests/run-with-compiler/quote-owners.scala b/tests/run-with-compiler/quote-owners.scala
index 3c8496604694..093480065dbb 100644
--- a/tests/run-with-compiler/quote-owners.scala
+++ b/tests/run-with-compiler/quote-owners.scala
@@ -12,7 +12,7 @@ object Test {
 
   def f: Expr[Int] = '{
     def ff: Int = {
-      ~g
+      $g
     }
     ff
   }
diff --git a/tests/run-with-compiler/quote-run-2.scala b/tests/run-with-compiler/quote-run-2.scala
index 7febe1ded44d..fcbbf576e03f 100644
--- a/tests/run-with-compiler/quote-run-2.scala
+++ b/tests/run-with-compiler/quote-run-2.scala
@@ -8,15 +8,15 @@ object Test {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
     def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
-      if (n == 0) '(1.0)
+      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 % 2 == 0) '{ { val y = $x * $x; ${powerCode(n / 2, 'y)} } }
+      else '{ $x * ${powerCode(n - 1, x)} }
 
-    println(powerCode(0, '(5)).show)
-    println(powerCode(1, '(5)).show)
-    println(powerCode(2, '(5)).show)
-    println(powerCode(3, '(5)).show)
-    println(powerCode(22, '(5)).show)
+    println(powerCode(0, '{5}).show)
+    println(powerCode(1, '{5}).show)
+    println(powerCode(2, '{5}).show)
+    println(powerCode(3, '{5}).show)
+    println(powerCode(22, '{5}).show)
   }
 }
diff --git a/tests/run-with-compiler/quote-run-many.scala b/tests/run-with-compiler/quote-run-many.scala
index 2a661d493df2..cabc6b8e96fc 100644
--- a/tests/run-with-compiler/quote-run-many.scala
+++ b/tests/run-with-compiler/quote-run-many.scala
@@ -5,7 +5,7 @@ object Test {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
     def expr(i: Int) = '{
-      val a = 3 + ~i.toExpr
+      val a = 3 + ${i.toExpr}
       2 + a
     }
     for (i <- 0 to 200)
diff --git a/tests/run-with-compiler/quote-run-staged-interpreter.scala b/tests/run-with-compiler/quote-run-staged-interpreter.scala
index 9af5dcde96a1..d60c58fc31e3 100644
--- a/tests/run-with-compiler/quote-run-staged-interpreter.scala
+++ b/tests/run-with-compiler/quote-run-staged-interpreter.scala
@@ -15,11 +15,11 @@ object Test {
   def compile(e: Exp, env: Map[String, Expr[Int]], keepLets: Boolean): Expr[Int] = {
     def compileImpl(e: Exp, env: Map[String, Expr[Int]]): Expr[Int] = e match {
       case Num(n) => n.toExpr
-      case Plus(e1, e2) => '(~compileImpl(e1, env) + ~compileImpl(e2, env))
+      case Plus(e1, e2) => '{${compileImpl(e1, env)} + ${compileImpl(e2, env)}}
       case Var(x) => env(x)
       case Let(x, e, body) =>
         if (keepLets)
-          '{ val y = ~compileImpl(e, env); ~compileImpl(body, env + (x -> '(y))) }
+          '{ val y = ${compileImpl(e, env)}; ${compileImpl(body, env + (x -> 'y)) } }
         else
           compileImpl(body, env + (x -> compileImpl(e, env)))
     }
@@ -31,7 +31,7 @@ object Test {
     val exp = Plus(Plus(Num(2), Var("x")), Num(4))
     val letExp = Let("x", Num(3), exp)
 
-    val res1 = '{ (x: Int) => ~compile(exp, Map("x" -> '(x)), false) }
+    val res1 = '{ (x: Int) => ${compile(exp, Map("x" -> 'x), false)} }
 
 
     println(res1.show)
diff --git a/tests/run-with-compiler/quote-show-blocks.scala b/tests/run-with-compiler/quote-show-blocks.scala
index cf0eef3f38c6..0c551c29a24e 100644
--- a/tests/run-with-compiler/quote-show-blocks.scala
+++ b/tests/run-with-compiler/quote-show-blocks.scala
@@ -6,16 +6,16 @@ object Test {
 
     def a(n: Int, x: Expr[Unit]): Expr[Unit] =
       if (n == 0) x
-      else a(n - 1, '{ println(~n.toExpr); ~x })
+      else a(n - 1, '{ println(${n.toExpr}); $x })
 
-    println(a(5, '()).show)
+    println(a(5, '{}).show)
 
 
     def b(n: Int, x: Expr[Unit]): Expr[Unit] =
       if (n == 0) x
-      else b(n - 1, '{ ~x; println(~n.toExpr) })
+      else b(n - 1, '{ $x; println(${n.toExpr}) })
 
-    println(b(5, '()).show)
+    println(b(5, '{}).show)
   }
 
 }
diff --git a/tests/run-with-compiler/quote-two-captured-ref.scala b/tests/run-with-compiler/quote-two-captured-ref.scala
index ce652e35c846..dc8f2ec3f0f8 100644
--- a/tests/run-with-compiler/quote-two-captured-ref.scala
+++ b/tests/run-with-compiler/quote-two-captured-ref.scala
@@ -6,11 +6,11 @@ object Test {
 
     val q = '{
       val x = 1
-      println(~{
+      println(${
         println(1)
-        val a = '(x)
-        val b = '(x)
-        '{ ~a + ~b }
+        val a = 'x
+        val b = 'x
+        '{ $a + $b }
       })
     }
 
diff --git a/tests/run-with-compiler/quote-type-tags.scala b/tests/run-with-compiler/quote-type-tags.scala
index aeab7a9938fd..dc33751495d3 100644
--- a/tests/run-with-compiler/quote-type-tags.scala
+++ b/tests/run-with-compiler/quote-type-tags.scala
@@ -5,18 +5,18 @@ object Test {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
     def asof[T: Type, U](x: Expr[T], t: Type[U]): Expr[U] =
-      '((~x).asInstanceOf[~t])
+      '{$x.asInstanceOf[$t]}
 
-    println(asof('(), '[Unit]).show)
-    println(asof('(true), '[Boolean]).show)
-    println(asof('(0.toByte), '[Byte]).show)
-    println(asof('( 'a' ), '[Char]).show)
-    println(asof('(1.toShort), '[Short]).show)
-    println(asof('(2), '[Int]).show)
-    println(asof('(3L), '[Long]).show)
-    println(asof('(4f), '[Float]).show)
-    println(asof('(5d), '[Double]).show)
+    println(asof('{}, '[Unit]).show)
+    println(asof('{true}, '[Boolean]).show)
+    println(asof('{0.toByte}, '[Byte]).show)
+    println(asof('{ 'a' }, '[Char]).show)
+    println(asof('{1.toShort}, '[Short]).show)
+    println(asof('{2}, '[Int]).show)
+    println(asof('{3L}, '[Long]).show)
+    println(asof('{4f}, '[Float]).show)
+    println(asof('{5d}, '[Double]).show)
 
-    println(asof('(5d), '[Boolean]).show) // Will clearly fail at runtime but the code can be generated
+    println(asof('{5d}, '[Boolean]).show) // Will clearly fail at runtime but the code can be generated
   }
 }
diff --git a/tests/run-with-compiler/quote-unrolled-foreach.scala b/tests/run-with-compiler/quote-unrolled-foreach.scala
index f81697147c96..4dc8f56cf628 100644
--- a/tests/run-with-compiler/quote-unrolled-foreach.scala
+++ b/tests/run-with-compiler/quote-unrolled-foreach.scala
@@ -5,27 +5,27 @@ object Test {
   implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
   def main(args: Array[String]): Unit = {
-    val code1 = '{ (arr: Array[Int], f: Int => Unit) => ~foreach1('(arr), '(f)) }
+    val code1 = '{ (arr: Array[Int], f: Int => Unit) => ${ foreach1('arr, 'f) } }
     println(code1.show)
     println()
 
-    val code1Tpe = '{ (arr: Array[String], f: String => Unit) => ~foreach1Tpe1('(arr), '(f)) }
+    val code1Tpe = '{ (arr: Array[String], f: String => Unit) => ${ foreach1Tpe1('arr, 'f) } }
     println(code1Tpe.show)
     println()
 
-    val code1Tpe2 = '{ (arr: Array[String], f: String => Unit) => ~foreach1Tpe1('(arr), '(f)) }
+    val code1Tpe2 = '{ (arr: Array[String], f: String => Unit) => ${ foreach1Tpe1('arr, 'f) } }
     println(code1Tpe2.show)
     println()
 
-    val code2 = '{ (arr: Array[Int]) => ~foreach1('(arr), '(i => System.out.println(i))) }
+    val code2 = '{ (arr: Array[Int]) => ${ foreach1('arr, '{i => System.out.println(i)}) } }
     println(code2.show)
     println()
 
-    val code3 = '{ (arr: Array[Int], f: Int => Unit) => ~foreach3('(arr), '(f)) }
+    val code3 = '{ (arr: Array[Int], f: Int => Unit) => ${ foreach3('arr, 'f) } }
     println(code3.show)
     println()
 
-    val code4 = '{ (arr: Array[Int], f: Int => Unit) => ~foreach4('(arr), '(f), 4) }
+    val code4 = '{ (arr: Array[Int], f: Int => Unit) => ${ foreach4('arr, 'f, 4) } }
     println(code4.show)
     println()
 
@@ -35,8 +35,8 @@ object Test {
 
 
     def printAll(arr: Array[Int]) = '{
-      val arr1 = ~arr.toExpr
-      ~foreach1('(arr1), '(x => println(x)))
+      val arr1 = ${ arr.toExpr }
+      ${ foreach1('arr1, '{x => println(x)}) }
     }
 
     println(printAll(Array(1, 3, 4, 5)).show)
@@ -44,91 +44,91 @@ object Test {
   }
 
   def foreach1(arrRef: Expr[Array[Int]], f: Expr[Int => Unit]): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
     while (i < size) {
-      val element: Int = (~arrRef)(i)
-      (~f)(element)
+      val element: Int = ($arrRef)(i)
+      ($f)(element)
       i += 1
     }
   }
 
   def foreach1Tpe1[T](arrRef: Expr[Array[T]], f: Expr[T => Unit])(implicit t: Type[T]): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
     while (i < size) {
-      val element: ~t = (~arrRef)(i)
-      (~f)(element)
+      val element: $t = ($arrRef)(i)
+      ($f)(element)
       i += 1
     }
   }
 
   def foreach1Tpe2[T: Type](arrRef: Expr[Array[T]], f: Expr[T => Unit]): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
     while (i < size) {
-      val element: T = (~arrRef)(i)
-      (~f)(element)
+      val element: T = ($arrRef)(i)
+      ($f)(element)
       i += 1
     }
   }
 
   def foreach2(arrRef: Expr[Array[Int]], f: Expr[Int => Unit]): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
     while (i < size) {
-      val element = (~arrRef)(i)
-      ~f('(element)) // Use AppliedFuntion
+      val element = ($arrRef)(i)
+      ${ f('element) } // Use AppliedFuntion
       i += 1
     }
   }
 
   def foreach3(arrRef: Expr[Array[Int]], f: Expr[Int => Unit]): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
     if (size % 3 != 0) throw new Exception("...")// for simplicity of the implementation
     while (i < size) {
-      (~f)((~arrRef)(i))
-      (~f)((~arrRef)(i + 1))
-      (~f)((~arrRef)(i + 2))
+      ($f)(($arrRef)(i))
+      ($f)(($arrRef)(i + 1))
+      ($f)(($arrRef)(i + 2))
       i += 3
     }
   }
 
   def foreach3_2(arrRef: Expr[Array[Int]], f: Expr[Int => Unit]): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
     if (size % 3 != 0) throw new Exception("...")// for simplicity of the implementation
     while (i < size) {
-      (~f)((~arrRef)(i))
-      (~f)((~arrRef)(i + 1))
-      (~f)((~arrRef)(i + 2))
+      ($f)(($arrRef)(i))
+      ($f)(($arrRef)(i + 1))
+      ($f)(($arrRef)(i + 2))
       i += 3
     }
   }
 
   def foreach4(arrRef: Expr[Array[Int]], f: Expr[Int => Unit], unrollSize: Int): Expr[Unit] = '{
-    val size = (~arrRef).length
+    val size = ($arrRef).length
     var i = 0
-    if (size % ~unrollSize.toExpr != 0) throw new Exception("...") // for simplicity of the implementation
+    if (size % ${unrollSize.toExpr} != 0) throw new Exception("...") // for simplicity of the implementation
     while (i < size) {
-      ~foreachInRange(0, unrollSize)(j => '{ (~f)((~arrRef)(i + ~j.toExpr)) })
-      i += ~unrollSize.toExpr
+      ${ foreachInRange(0, unrollSize)(j => '{ ($f)(($arrRef)(i + ${j.toExpr})) }) }
+      i += ${unrollSize.toExpr}
     }
   }
 
   implicit object ArrayIntIsLiftable extends Liftable[Array[Int]] {
     override def toExpr(x: Array[Int]): Expr[Array[Int]] = '{
-      val array = new Array[Int](~x.length.toExpr)
-      ~foreachInRange(0, x.length)(i => '{ array(~i.toExpr) = ~x(i).toExpr})
+      val array = new Array[Int](${x.length.toExpr})
+      ${ foreachInRange(0, x.length)(i => '{ array(${i.toExpr}) = ${x(i).toExpr}}) }
       array
     }
   }
 
   def foreachInRange(start: Int, end: Int)(f: Int => Expr[Unit]): Expr[Unit] = {
     @tailrec def unroll(i: Int, acc: Expr[Unit]): Expr[Unit] =
-      if (i < end) unroll(i + 1, '{ ~acc; ~f(i) }) else acc
-    if (start < end) unroll(start + 1, f(start)) else '()
+      if (i < end) unroll(i + 1, '{ $acc; ${f(i)} }) else acc
+    if (start < end) unroll(start + 1, f(start)) else '{}
   }
 
 }
diff --git a/tests/run-with-compiler/quote-var.scala b/tests/run-with-compiler/quote-var.scala
index e19d5992c471..895e8ca67b4f 100644
--- a/tests/run-with-compiler/quote-var.scala
+++ b/tests/run-with-compiler/quote-var.scala
@@ -9,21 +9,23 @@ object Test {
 
   object Var {
     def apply(init: Expr[String])(body: Var => Expr[String]): Expr[String] = '{
-      var x = ~init
-      ~body(
-        new Var {
-          def get: Expr[String] = '(x)
-          def update(e: Expr[String]): Expr[Unit] = '{ x = ~e }
-        }
-      )
+      var x = $init
+      ${
+        body(
+          new Var {
+            def get: Expr[String] = 'x
+            def update(e: Expr[String]): Expr[Unit] = '{ x = $e }
+          }
+        )
+      }
     }
   }
 
 
-  def test1(): Expr[String] = Var('("abc")) { x =>
+  def test1(): Expr[String] = Var('{"abc"}) { x =>
     '{
-      ~x.update('("xyz"))
-      ~x.get
+      ${ x.update('{"xyz"}) }
+      ${ x.get }
     }
   }
 
diff --git a/tests/run-with-compiler/reflect-select-constructor/assert_1.scala b/tests/run-with-compiler/reflect-select-constructor/assert_1.scala
index 15416a9a544d..1a34880b00db 100644
--- a/tests/run-with-compiler/reflect-select-constructor/assert_1.scala
+++ b/tests/run-with-compiler/reflect-select-constructor/assert_1.scala
@@ -3,7 +3,7 @@ import scala.tasty._
 
 object scalatest {
 
-  inline def assert(condition: => Boolean): Unit = ~assertImpl('(condition), '(""))
+  inline def assert(condition: => Boolean): Unit = ${ assertImpl('condition, '{""}) }
 
   def assertImpl(cond: Expr[Boolean], clue: Expr[Any])(implicit refl: Reflection): Expr[Unit] = {
     import refl._
@@ -22,7 +22,7 @@ object scalatest {
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
-              val code = '{ scala.Predef.assert(~b) }
+              val code = '{ scala.Predef.assert($b) }
               code.unseal
             }
           }
@@ -36,7 +36,7 @@ object scalatest {
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
-              val code = '{ scala.Predef.assert(~b) }
+              val code = '{ scala.Predef.assert($b) }
               code.unseal
             }
           }
diff --git a/tests/run-with-compiler/reflect-select-copy/assert_1.scala b/tests/run-with-compiler/reflect-select-copy/assert_1.scala
index 3537676ff1e2..7b11c5a55ecb 100644
--- a/tests/run-with-compiler/reflect-select-copy/assert_1.scala
+++ b/tests/run-with-compiler/reflect-select-copy/assert_1.scala
@@ -3,7 +3,7 @@ import scala.tasty._
 
 object scalatest {
 
-  inline def assert(condition: => Boolean): Unit = ~assertImpl('(condition), '(""))
+  inline def assert(condition: => Boolean): Unit = ${ assertImpl('condition, '{""}) }
 
   def assertImpl(cond: Expr[Boolean], clue: Expr[Any])(implicit refl: Reflection): Expr[Unit] = {
     import refl._
@@ -21,7 +21,7 @@ object scalatest {
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
-              val code = '{ scala.Predef.assert(~b) }
+              val code = '{ scala.Predef.assert(${b}) }
               code.unseal
             }
           }
@@ -34,7 +34,7 @@ object scalatest {
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
-              val code = '{ scala.Predef.assert(~b) }
+              val code = '{ scala.Predef.assert(${b}) }
               code.unseal
             }
           }
diff --git a/tests/run-with-compiler/shonan-hmm-simple.scala b/tests/run-with-compiler/shonan-hmm-simple.scala
index a0b67ab62177..82bf29ede43a 100644
--- a/tests/run-with-compiler/shonan-hmm-simple.scala
+++ b/tests/run-with-compiler/shonan-hmm-simple.scala
@@ -17,11 +17,11 @@ class RingInt extends Ring[Int] {
 }
 
 class RingIntExpr extends Ring[Expr[Int]] {
-  val zero = '(0)
-  val one  = '(1)
-  val add  = (x, y) => '(~x + ~y)
-  val sub  = (x, y) => '(~x - ~y)
-  val mul  = (x, y) => '(~x * ~y)
+  val zero = '{0}
+  val one  = '{1}
+  val add  = (x, y) => '{$x + $y}
+  val sub  = (x, y) => '{$x - $y}
+  val mul  = (x, y) => '{$x * $y}
 }
 
 class RingComplex[U](u: Ring[U]) extends Ring[Complex[U]] {
@@ -71,7 +71,7 @@ case class Complex[T](re: T, im: T)
 
 object Complex {
   implicit def isLiftable[T: Type: Liftable]: Liftable[Complex[T]] = new Liftable[Complex[T]] {
-    def toExpr(comp: Complex[T]): Expr[Complex[T]] = '(Complex(~comp.re.toExpr, ~comp.im.toExpr))
+    def toExpr(comp: Complex[T]): Expr[Complex[T]] = '{Complex(${comp.re.toExpr}, ${comp.im.toExpr})}
   }
 }
 
@@ -99,10 +99,10 @@ class StaticVecOps[T] extends VecOps[Int, T] {
 
 class ExprVecOps[T: Type] extends VecOps[Expr[Int], Expr[T]] {
   val reduce: ((Expr[T], Expr[T]) => Expr[T], Expr[T], Vec[Expr[Int], Expr[T]]) => Expr[T] = (plus, zero, vec) => '{
-    var sum = ~zero
+    var sum = $zero
     var i = 0
-    while (i < ~vec.size) {
-      sum = ~{ plus('(sum), vec.get('(i))) }
+    while (i < ${vec.size}) {
+      sum = ${ plus('sum, vec.get('i)) }
       i += 1
     }
     sum
@@ -154,10 +154,10 @@ object Test {
     val resCode2: Expr[(Array[Int], Array[Int]) => Int] = '{
       (arr1, arr2) =>
         if (arr1.length != arr2.length) throw new Exception("...")
-        ~{
+        ${
           blasExprIntExpr.dot(
-            new Vec('(arr1.size), i => '(arr1(~i))),
-            new Vec('(arr2.size), i => '(arr2(~i)))
+            new Vec('{arr1.size}, i => '{arr1($i)}),
+            new Vec('{arr2.size}, i => '{arr2($i)})
           )
         }
     }
@@ -177,10 +177,10 @@ object Test {
     val blasExprIntPVExpr = new Blas1(new RingPV[Int](new RingInt, new RingIntExpr), new StaticVecOps)
     val resCode4: Expr[Array[Int] => Int] = '{
       arr =>
-        if (arr.length != ~vec2.size.toExpr) throw new Exception("...")
-        ~{
+        if (arr.length != ${vec2.size.toExpr}) throw new Exception("...")
+        ${
           blasExprIntPVExpr.dot(
-            new Vec(vec2.size, i => Dyn('(arr(~i.toExpr)))),
+            new Vec(vec2.size, i => Dyn('{arr(${i.toExpr})})),
             vec2.map(i => Sta(i))
           ).expr
         }
@@ -194,13 +194,13 @@ object Test {
     val blasExprComplexPVInt = new Blas1[Int, Complex[PV[Int]]](new RingComplex(new RingPV[Int](new RingInt, new RingIntExpr)), new StaticVecOps)
     val resCode5: Expr[Array[Complex[Int]] => Complex[Int]] = '{
       arr =>
-        if (arr.length != ~cmpxVec2.size.toExpr) throw new Exception("...")
-        ~{
+        if (arr.length != ${cmpxVec2.size.toExpr}) throw new Exception("...")
+        ${
           val cpx = blasExprComplexPVInt.dot(
-            new Vec(cmpxVec2.size, i => Complex(Dyn('(arr(~i.toExpr).re)), Dyn('(arr(~i.toExpr).im)))),
+            new Vec(cmpxVec2.size, i => Complex(Dyn('{arr(${i.toExpr}).re}), Dyn('{arr(${i.toExpr}).im}))),
             new Vec(cmpxVec2.size, i => Complex(Sta(cmpxVec2.get(i).re), Sta(cmpxVec2.get(i).im)))
           )
-          '(Complex(~cpx.re.expr, ~cpx.im.expr))
+          '{Complex(${cpx.re.expr}, ${cpx.im.expr})}
         }
     }
     println(resCode5.show)
@@ -212,7 +212,7 @@ object Test {
     val dotIntOptExpr = new Blas1(RingPVInt, new StaticVecOps).dot
     // will generate the code '{ ((arr: scala.Array[scala.Int]) => arr.apply(1).+(arr.apply(3))) }
     val staticVec = Vec[Int, PV[Int]](5, i => Sta((i % 2)))
-    val code = '{(arr: Array[Int]) => ~dotIntOptExpr(Vec(5, i => Dyn('(arr(~i.toExpr)))), staticVec).expr }
+    val code = '{(arr: Array[Int]) => ${dotIntOptExpr(Vec(5, i => Dyn('{arr(${i.toExpr})})), staticVec).expr} }
     println(code.show)
     println()
   }
diff --git a/tests/run-with-compiler/shonan-hmm/Complex.scala b/tests/run-with-compiler/shonan-hmm/Complex.scala
index da3490b6f228..b73e0bbfade0 100644
--- a/tests/run-with-compiler/shonan-hmm/Complex.scala
+++ b/tests/run-with-compiler/shonan-hmm/Complex.scala
@@ -5,11 +5,11 @@ case class Complex[T](re: T, im: T)
 
 object Complex {
   implicit def complexIsLiftable[T: Type: Liftable]: Liftable[Complex[T]] = new Liftable {
-    def toExpr(c: Complex[T]): Expr[Complex[T]] = '{ Complex(~c.re.toExpr, ~c.im.toExpr) }
+    def toExpr(c: Complex[T]): Expr[Complex[T]] = '{ Complex(${c.re.toExpr}, ${c.im.toExpr}) }
   }
 
- def of_complex_expr(x: Expr[Complex[Int]]): Complex[Expr[Int]] = Complex('((~x).re), '((~x).im))
- def of_expr_complex(x: Complex[Expr[Int]]): Expr[Complex[Int]] = '(Complex(~x.re, ~x.im))
+ def of_complex_expr(x: Expr[Complex[Int]]): Complex[Expr[Int]] = Complex('{$x.re}, '{$x.im})
+ def of_expr_complex(x: Complex[Expr[Int]]): Expr[Complex[Int]] = '{Complex(${x.re}, ${x.im})}
 
 
 }
\ No newline at end of file
diff --git a/tests/run-with-compiler/shonan-hmm/Lifters.scala b/tests/run-with-compiler/shonan-hmm/Lifters.scala
index e852085b2d0c..eead03f2d15d 100644
--- a/tests/run-with-compiler/shonan-hmm/Lifters.scala
+++ b/tests/run-with-compiler/shonan-hmm/Lifters.scala
@@ -7,22 +7,22 @@ import scala.quoted._
 object Lifters {
 
   implicit def ClassTagIsLiftable[T : Type](implicit ct: ClassTag[T]): Liftable[ClassTag[T]] =
-    ct => '(ClassTag(~ct.runtimeClass.toExpr))
+    ct => '{ClassTag(${ct.runtimeClass.toExpr})}
 
   implicit def ArrayIsLiftable[T : Type: ClassTag](implicit l: Liftable[T]): Liftable[Array[T]] = arr => '{
-    val array = new Array[T](~arr.length.toExpr)(~implicitly[ClassTag[T]].toExpr)
-    ~initArray(arr, '(array))
+    val array = new Array[T](${arr.length.toExpr})(${implicitly[ClassTag[T]].toExpr})
+    ${initArray(arr, 'array)}
   }
 
   implicit def IntArrayIsLiftable: Liftable[Array[Int]] = arr => '{
-    val array = new Array[Int](~arr.length.toExpr)
-    ~initArray(arr, '(array))
+    val array = new Array[Int](${arr.length.toExpr})
+    ${initArray(arr, 'array)}
   }
 
   private def initArray[T : Liftable : Type](arr: Array[T], array: Expr[Array[T]]): Expr[Array[T]] = {
     UnrolledExpr.block(
       arr.zipWithIndex.map {
-        case (x, i) => '{ (~array)(~i.toExpr) = ~x.toExpr }
+        case (x, i) => '{ $array(${i.toExpr}) = ${x.toExpr} }
       }.toList,
       array)
   }
diff --git a/tests/run-with-compiler/shonan-hmm/MVmult.scala b/tests/run-with-compiler/shonan-hmm/MVmult.scala
index a476c1919831..7c4198a0622b 100644
--- a/tests/run-with-compiler/shonan-hmm/MVmult.scala
+++ b/tests/run-with-compiler/shonan-hmm/MVmult.scala
@@ -26,10 +26,10 @@ object MVmult {
     (vout, a, v) => {
       val n = vout.length
       val m = v.length
-      ~{
-        val vout_ = OVec('(n), (i, x: Expr[Int]) => '(vout(~i) = ~x))
-        val a_ = Vec('(n), (i: Expr[Int]) => Vec('(m), (j: Expr[Int]) => '{ a(~i)(~j) } ))
-        val v_ = Vec('(m), (i: Expr[Int]) => '(v(~i)))
+      ${
+        val vout_ = OVec('n, (i, x: Expr[Int]) => '{vout($i) = $x})
+        val a_ = Vec('n, (i: Expr[Int]) => Vec('m, (j: Expr[Int]) => '{ a($i)($j) } ))
+        val v_ = Vec('m, (i: Expr[Int]) => '{v($i)})
 
         val MV = new MVmult[Expr[Int], Expr[Int], Expr[Unit]](RingIntExpr, new VecRDyn)
         MV.mvmult(vout_, a_, v_)
@@ -41,12 +41,12 @@ object MVmult {
     val MV = new MVmult[Int, Expr[Int], Expr[Unit]](RingIntExpr, new VecRStaDim(RingIntExpr))
     '{
       (vout, a, v) => {
-        if (~n.toExpr != vout.length) throw new IndexOutOfBoundsException(~n.toString.toExpr)
-        if (~m.toExpr != v.length) throw new IndexOutOfBoundsException(~m.toString.toExpr)
-        ~{
-          val vout_ = OVec(n, (i, x: Expr[Int]) => '(vout(~i.toExpr) = ~x))
-          val a_ = Vec(n, i => Vec(m, j => '{ a(~i.toExpr)(~j.toExpr) } ))
-          val v_ = Vec(m, i => '(v(~i.toExpr)))
+        if (${n.toExpr} != vout.length) throw new IndexOutOfBoundsException(${n.toString.toExpr})
+        if (${m.toExpr} != v.length) throw new IndexOutOfBoundsException(${m.toString.toExpr})
+        ${
+          val vout_ = OVec(n, (i, x: Expr[Int]) => '{vout(${i.toExpr}) = $x})
+          val a_ = Vec(n, i => Vec(m, j => '{ a(${i.toExpr})(${j.toExpr}) } ))
+          val v_ = Vec(m, i => '{v(${i.toExpr})})
 
           MV.mvmult(vout_, a_, v_)
         }
@@ -57,9 +57,9 @@ object MVmult {
   def mvmult_ac(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
     import Lifters._
     '{
-      val arr = ~a.toExpr
-      ~{
-        val (n, m, a2) = amat1(a, '(arr))
+      val arr = ${a.toExpr}
+      ${
+        val (n, m, a2) = amat1(a, 'arr)
         mvmult_abs0(new RingIntPExpr, new VecRStaDyn(new RingIntPExpr))(n, m, a2)
       }
     }
@@ -68,9 +68,9 @@ object MVmult {
   def mvmult_opt(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
     import Lifters._
     '{
-      val arr = ~a.toExpr
-      ~{
-        val (n, m, a2) = amat1(a, '(arr))
+      val arr = ${a.toExpr}
+      ${
+        val (n, m, a2) = amat1(a, 'arr)
         mvmult_abs0(new RingIntOPExpr, new VecRStaDyn(new RingIntPExpr))(n, m, a2)
       }
     }
@@ -79,9 +79,9 @@ object MVmult {
   def mvmult_roll(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
     import Lifters._
     '{
-      val arr = ~a.toExpr
-      ~{
-        val (n, m, a2) = amat1(a, '(arr))
+      val arr = ${a.toExpr}
+      ${
+        val (n, m, a2) = amat1(a, 'arr)
         mvmult_abs0(new RingIntOPExpr, new VecRStaOptDynInt(new RingIntPExpr))(n, m, a2)
       }
     }
@@ -104,11 +104,11 @@ object MVmult {
     def loop(i: Int, acc: List[Expr[Array[Int]]]): Expr[T] = {
       if (i >= a.length) cont(acc.toArray.reverse)
       else if (a(i).count(_ != 0) < VecRStaOptDynInt.threshold) {
-        val default: Expr[Array[Int]] = '(null.asInstanceOf[Array[Int]]) // never accessed
+        val default: Expr[Array[Int]] = '{null.asInstanceOf[Array[Int]]} // never accessed
         loop(i + 1, default :: acc)
       } else '{
-        val row = ~a(i).toExpr
-        ~{ loop(i + 1, '(row) :: acc) }
+        val row = ${a(i).toExpr}
+        ${ loop(i + 1, 'row :: acc) }
       }
     }
     loop(0, Nil)
@@ -119,8 +119,8 @@ object MVmult {
     val m = a(0).length
     val vec: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
       case (Sta(i), Sta(j)) => Sta(a(i)(j))
-      case (Sta(i), Dyn(j)) => Dyn('((~aa)(~i.toExpr)(~j)))
-      case (i, j) => Dyn('{ (~aa)(~(Dyns.dyni(i)))(~(Dyns.dyni(j))) })
+      case (Sta(i), Dyn(j)) => Dyn('{$aa(${i.toExpr})($j)})
+      case (i, j) => Dyn('{ $aa(${Dyns.dyni(i)})(${Dyns.dyni(j)}) })
     }))
     (n, m, vec)
   }
@@ -130,7 +130,7 @@ object MVmult {
     val m = a(0).length
     val vec: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
       case (Sta(i), Sta(j)) => Sta(a(i)(j))
-      case (Sta(i), Dyn(j)) => Dyn('((~refs(i))(~j)))
+      case (Sta(i), Dyn(j)) => Dyn('{(${refs(i)})($j)})
     }))
     (n, m, vec)
   }
@@ -151,23 +151,23 @@ object MVmult {
   def copy_row1: Array[Int] => (Expr[Int] => Expr[Int]) = v => {
     import Lifters._
     val arr = v.toExpr
-    i => '{ (~arr).apply(~i) }
+    i => '{ ($arr).apply($i) }
   }
 
   def copy_row_let: Array[Int] => (Expr[Int] => Expr[Int]) = v => {
     import Lifters._
     val arr: Expr[Array[Int]] = ??? // FIXME used genlet v.toExpr
-    i => '{ (~arr).apply(~i) }
+    i => '{ ($arr).apply($i) }
   }
 
   private def mvmult_abs0(ring: Ring[PV[Int]], vecOp: VecROp[PV[Int], PV[Int], Expr[Unit]])(n: Int, m: Int, a: Vec[PV[Int], Vec[PV[Int], PV[Int]]]): Expr[(Array[Int], Array[Int]) => Unit] = {
     '{
       (vout, v) => {
-        if (~n.toExpr != vout.length) throw new IndexOutOfBoundsException(~n.toString.toExpr)
-        if (~m.toExpr != v.length) throw new IndexOutOfBoundsException(~m.toString.toExpr)
-        ~{
-          val vout_ : OVec[PV[Int], PV[Int], Expr[Unit]] = OVec(Sta(n), (i, x) => '(vout(~Dyns.dyni(i)) = ~Dyns.dyn(x)))
-          val v_ : Vec[PV[Int], PV[Int]] = Vec(Sta(m), i => Dyn('(v(~Dyns.dyni(i)))))
+        if (${n.toExpr} != vout.length) throw new IndexOutOfBoundsException(${n.toString.toExpr})
+        if (${m.toExpr} != v.length) throw new IndexOutOfBoundsException(${m.toString.toExpr})
+        ${
+          val vout_ : OVec[PV[Int], PV[Int], Expr[Unit]] = OVec(Sta(n), (i, x) => '{vout(${Dyns.dyni(i)}) = ${Dyns.dyn(x)}})
+          val v_ : Vec[PV[Int], PV[Int]] = Vec(Sta(m), i => Dyn('{v(${Dyns.dyni(i)})}))
           val MV = new MVmult[PV[Int], PV[Int], Expr[Unit]](ring, vecOp)
           MV.mvmult(vout_, a, v_)
         }
diff --git a/tests/run-with-compiler/shonan-hmm/Ring.scala b/tests/run-with-compiler/shonan-hmm/Ring.scala
index 521fff3ac819..3763017d8424 100644
--- a/tests/run-with-compiler/shonan-hmm/Ring.scala
+++ b/tests/run-with-compiler/shonan-hmm/Ring.scala
@@ -25,11 +25,11 @@ object RingInt extends Ring[Int] {
 }
 
 object RingIntExpr extends Ring[Expr[Int]] {
-  val zero = '(0)
-  val one  = '(1)
-  val add  = (x, y) => '(~x + ~y)
-  val sub  = (x, y) => '(~x - ~y)
-  val mul  = (x, y) => '(~x * ~y)
+  val zero = '{0}
+  val one  = '{1}
+  val add  = (x, y) => '{$x + $y}
+  val sub  = (x, y) => '{$x - $y}
+  val mul  = (x, y) => '{$x * $y}
   override def toString(): String = "RingIntExpr"
 }
 
diff --git a/tests/run-with-compiler/shonan-hmm/Test.scala b/tests/run-with-compiler/shonan-hmm/Test.scala
index 38341199bd17..4aec6d833bb6 100644
--- a/tests/run-with-compiler/shonan-hmm/Test.scala
+++ b/tests/run-with-compiler/shonan-hmm/Test.scala
@@ -18,7 +18,7 @@ object Test {
       val intExprComplex = new RingComplex(RingIntExpr)
       import intExprComplex._
 
-      val res = Complex('(1), '(2)) * Complex('(4), '(2))
+      val res = Complex('{1}, '{2}) * Complex('{4}, '{2})
       println(s"Complex(${res.re.show}, ${res.im.show})")
     }
 
@@ -26,7 +26,7 @@ object Test {
     //   val intExprComplex = implicitly[Ring[Expr[Complex[Int]]]]
     //   import intExprComplex._
 
-    //   val res = '(Complex(1, 2)) * '(Complex(4, 2))
+    //   val res = '{Complex(1, 2)} * '{Complex(4, 2)}
     //   println(res.show)
     // }
 
diff --git a/tests/run-with-compiler/shonan-hmm/UnrolledExpr.scala b/tests/run-with-compiler/shonan-hmm/UnrolledExpr.scala
index b76edae7fd92..56ab8a676740 100644
--- a/tests/run-with-compiler/shonan-hmm/UnrolledExpr.scala
+++ b/tests/run-with-compiler/shonan-hmm/UnrolledExpr.scala
@@ -10,7 +10,7 @@ object UnrolledExpr {
   // TODO support blocks in the compiler to avoid creating trees of blocks?
   def block[T: Type](stats: Iterable[Expr[_]], expr: Expr[T]): Expr[T] = {
     def rec(stats: List[Expr[_]]): Expr[T] = stats match {
-      case x :: xs => '{ ~x; ~rec(xs) }
+      case x :: xs => '{ $x; ${rec(xs)} }
       case Nil => expr
     }
     rec(stats.toList)
@@ -21,7 +21,7 @@ object UnrolledExpr {
 class UnrolledExpr[T: Liftable, It <: Iterable[T]](xs: It) {
   import UnrolledExpr._
 
-  def foreach[U](f: T => Expr[U]): Expr[Unit] = block(xs.map(f), '())
+  def foreach[U](f: T => Expr[U]): Expr[Unit] = block(xs.map(f), '{})
 
   def withFilter(f: T => Boolean): UnrolledExpr[T, Iterable[T]] = new UnrolledExpr(xs.filter(f))
 
diff --git a/tests/run-with-compiler/shonan-hmm/VecOp.scala b/tests/run-with-compiler/shonan-hmm/VecOp.scala
index c8bbbd6d3b69..d4764b9f4487 100644
--- a/tests/run-with-compiler/shonan-hmm/VecOp.scala
+++ b/tests/run-with-compiler/shonan-hmm/VecOp.scala
@@ -15,8 +15,8 @@ class VecSta extends VecOp[Int, Unit] {
 class VecDyn extends VecOp[Expr[Int], Expr[Unit]] {
   def iter: Vec[Expr[Int], Expr[Unit]] => Expr[Unit] = arr => '{
     var i = 0
-    while (i < ~arr.size) {
-      ~arr('(i))
+    while (i < ${arr.size}) {
+      ${arr('i)}
       i += 1
     }
   }
diff --git a/tests/run-with-compiler/shonan-hmm/VecROp.scala b/tests/run-with-compiler/shonan-hmm/VecROp.scala
index 3d8b8aa63ebe..2fab7753e964 100644
--- a/tests/run-with-compiler/shonan-hmm/VecROp.scala
+++ b/tests/run-with-compiler/shonan-hmm/VecROp.scala
@@ -19,10 +19,10 @@ class StaticVecR[T](r: Ring[T]) extends VecSta with VecROp[Int, T, Unit] {
 class VecRDyn[T: Type] extends VecDyn with VecROp[Expr[Int], Expr[T], Expr[Unit]] {
   def reduce: ((Expr[T], Expr[T]) => Expr[T], Expr[T], Vec[Expr[Int], Expr[T]]) => Expr[T] = {
     (plus, zero, vec) => '{
-      var sum = ~zero
+      var sum = $zero
       var i = 0
-      while (i < ~vec.size) {
-        sum = ~{ plus('(sum), vec('(i))) }
+      while (i < ${vec.size}) {
+        sum = ${ plus('sum, vec('i)) }
         i += 1
       }
       sum
@@ -34,13 +34,13 @@ class VecRDyn[T: Type] extends VecDyn with VecROp[Expr[Int], Expr[T], Expr[Unit]
 class VecRStaDim[T: Type](r: Ring[T]) extends VecROp[Int, T, Expr[Unit]]  {
   val M = new StaticVecR[T](r)
   def reduce: ((T, T) => T, T, Vec[Int, T]) => T = M.reduce
-  val seq: (Expr[Unit], Expr[Unit]) => Expr[Unit] = (e1, e2) => '{ ~e1; ~e2 }
+  val seq: (Expr[Unit], Expr[Unit]) => Expr[Unit] = (e1, e2) => '{ $e1; $e2 }
   // val iter:  (arr: Vec[]) = reduce seq .<()>. arr
   def iter: Vec[Int, Expr[Unit]] => Expr[Unit] = arr => {
     def loop(i: Int, acc: Expr[Unit]): Expr[Unit] =
-      if (i < arr.size) loop(i + 1, '{ ~acc; ~arr.get(i) })
+      if (i < arr.size) loop(i + 1, '{ $acc; ${arr.get(i)} })
       else acc
-    loop(0, '())
+    loop(0, '{})
   }
   override def toString(): String = s"VecRStaDim($r)"
 }
@@ -58,9 +58,9 @@ class VecRStaDyn[T : Type : Liftable](r: Ring[PV[T]]) extends VecROp[PV[Int], PV
     arr.size match {
       case Sta(n) =>
         def loop(i: Int, acc: Expr[Unit]): Expr[Unit] =
-          if (i < n) loop(i + 1, '{ ~acc; ~arr.get(Sta(i)) })
+          if (i < n) loop(i + 1, '{ $acc; ${arr.get(Sta(i))} })
           else acc
-        loop(0, '())
+        loop(0, '{})
       case Dyn(n) =>
           '{ "TODO"; () }
 
diff --git a/tests/run-with-compiler/shonan-hmm/Vmults.scala b/tests/run-with-compiler/shonan-hmm/Vmults.scala
index a3bf8a775451..0e3b590f3123 100644
--- a/tests/run-with-compiler/shonan-hmm/Vmults.scala
+++ b/tests/run-with-compiler/shonan-hmm/Vmults.scala
@@ -24,10 +24,10 @@ object Vmults {
   def vmultCA: Expr[(Array[Complex[Int]], Array[Complex[Int]], Array[Complex[Int]]) => Unit] = '{
     (vout, v1, v2) => {
       val n = vout.length
-      ~{
-        val vout_ = OVec[Expr[Int], Complex[Expr[Int]], Expr[Unit]]('(n), (i, v) => '(vout(~i) = ~Complex.of_expr_complex(v)))
-        val v1_ = Vec ('(n), i => Complex.of_complex_expr('(v1(~i))))
-        val v2_ = Vec ('(n), i => Complex.of_complex_expr('(v2(~i))))
+      ${
+        val vout_ = OVec[Expr[Int], Complex[Expr[Int]], Expr[Unit]]('n, (i, v) => '{vout($i) = ${Complex.of_expr_complex(v)}})
+        val v1_ = Vec ('n, i => Complex.of_complex_expr('{v1($i)}))
+        val v2_ = Vec ('n, i => Complex.of_complex_expr('{v2($i)}))
 
         val V = new Vmult[Expr[Int], Complex[Expr[Int]], Expr[Unit]](RingComplex(RingIntExpr), new VecDyn)
         V.vmult(vout_, v1_, v2_)
diff --git a/tests/run-with-compiler/tasty-extractors-constants-2/quoted_1.scala b/tests/run-with-compiler/tasty-extractors-constants-2/quoted_1.scala
index d3e1ecdba402..61fae32cf121 100644
--- a/tests/run-with-compiler/tasty-extractors-constants-2/quoted_1.scala
+++ b/tests/run-with-compiler/tasty-extractors-constants-2/quoted_1.scala
@@ -6,7 +6,7 @@ import scala.tasty.util._
 
 object Macros {
 
-  inline def testMacro: Unit = ~impl
+  inline def testMacro: Unit = ${impl}
 
   def impl(implicit reflect: Reflection): Expr[Unit] = {
     // 2 is a lifted constant
@@ -19,8 +19,8 @@ object Macros {
     val run2  = power(n.toExpr, 4.0.toExpr).run
 
     // n is a constant in a quote
-    val show3 = power('(2), 5.0.toExpr).show
-    val run3 =  power('(2), 5.0.toExpr).run
+    val show3 = power('{2}, 5.0.toExpr).show
+    val run3 =  power('{2}, 5.0.toExpr).run
 
     // n2 is clearly not a constant
     // FIXME
@@ -29,17 +29,17 @@ object Macros {
 //    val run4  = (power(n2, 6.0.toExpr).run)
 
     '{
-      println(~show1.toExpr)
-      println(~run1.toExpr)
+      println(${show1.toExpr})
+      println(${run1.toExpr})
       println()
-      println(~show2.toExpr)
-      println(~run2.toExpr)
+      println(${show2.toExpr})
+      println(${run2.toExpr})
       println()
-      println(~show3.toExpr)
-      println(~run3.toExpr)
+      println(${show3.toExpr})
+      println(${run3.toExpr})
 //      println()
-//      println(~show4.toExpr)
-//      println(~run4.toExpr)
+//      println(${show4.toExpr})
+//      println(${run4.toExpr})
     }
   }
 
@@ -49,15 +49,15 @@ object Macros {
     val Constant = new ConstantExtractor(reflect)
     n match {
       case Constant(n1) => powerCode(n1, x)
-      case _ => '{ dynamicPower(~n, ~x) }
+      case _ => '{ dynamicPower($n, $x) }
     }
   }
 
   def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
-    if (n == 0) '(1.0)
+    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 % 2 == 0) '{ { val y = $x * $x; ${powerCode(n / 2, 'y)} } }
+    else '{ $x * ${powerCode(n - 1, x)} }
 
   def dynamicPower(n: Int, x: Double): Double =
     if (n == 0) 1.0
diff --git a/tests/run-with-compiler/tasty-unsafe-let/quoted_1.scala b/tests/run-with-compiler/tasty-unsafe-let/quoted_1.scala
index 793cb85c9e47..5116979a3b96 100644
--- a/tests/run-with-compiler/tasty-unsafe-let/quoted_1.scala
+++ b/tests/run-with-compiler/tasty-unsafe-let/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Macros {
 
   inline def let[T](rhs: T)(body: => T => Unit): Unit =
-    ~impl('(rhs), '(body))
+    ${ impl('rhs, 'body) }
 
   private def impl[T](rhs: Expr[T], body: Expr[T => Unit])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
diff --git a/tests/run/Course-2002-07.check b/tests/run/Course-2002-07.check
index 75e956f31054..aa933e066fdb 100644
--- a/tests/run/Course-2002-07.check
+++ b/tests/run/Course-2002-07.check
@@ -91,14 +91,14 @@ List(1, 6) = heads(List(List(), List(1, 2, 3, 4, 5), List(6)))
 List(1, 3, 5) = heads(List(List(1, 2), List(3, 4), List(5, 6)))
 
 f (x) = Prod(Var(x), Var(x))
-f'(x) = Sum(Prod(Var(x), Number(1)), Prod(Var(x), Number(1)))
+f'{x} = Sum(Prod(Var(x), Number(1)), Prod(Var(x), Number(1)))
 
 f (x) = x * x
-f'(x) = x * 1 + x * 1
+f'{x} = x * 1 + x * 1
 g (x) = 2 * x * x + 3 * x
-g'(x) = 2 * x * 1 + x * (2 * 1 + x * 0) + 3 * 1 + x * 0
+g'{x} = 2 * x * 1 + x * (2 * 1 + x * 0) + 3 * 1 + x * 0
 g (3) = 27
-g'(3) = 15
+g'{3} = 15
 
 ta(x) = x + 3
 tb(x) = x + 3
diff --git a/tests/run/Course-2002-07.scala b/tests/run/Course-2002-07.scala
index 779d27188075..c168313a56d7 100644
--- a/tests/run/Course-2002-07.scala
+++ b/tests/run/Course-2002-07.scala
@@ -364,7 +364,7 @@ object M9 {
     val f0 = Prod(x, x);
     val f1 = f0 derive x;
     Console.println("f (x) = " + f0);
-    Console.println("f'(x) = " + f1);
+    Console.println("f'{x} = " + f1);
     Console.println();
   }
 
@@ -431,14 +431,14 @@ object MA {
     val f0 = x * x;
     val f1 = f0 derive x;
     Console.println("f (x) = " + f0);
-    Console.println("f'(x) = " + f1);
+    Console.println("f'{x} = " + f1);
 
     val g0 = Number(2) * x * x + Number(3) * x;
     val g1 = g0 derive x;
     Console.println("g (x) = " + g0);
-    Console.println("g'(x) = " + g1);
+    Console.println("g'{x} = " + g1);
     Console.println("g (3) = " + evalvars(List(("x",3)))(g0));
-    Console.println("g'(3) = " + evalvars(List(("x",3)))(g1));
+    Console.println("g'{3} = " + evalvars(List(("x",3)))(g1));
 
     Console.println();
   }
diff --git a/tests/run/f-interpolation-1/FQuote_1.scala b/tests/run/f-interpolation-1/FQuote_1.scala
index c428ecfe0c0d..e65c48adc772 100644
--- a/tests/run/f-interpolation-1/FQuote_1.scala
+++ b/tests/run/f-interpolation-1/FQuote_1.scala
@@ -6,7 +6,7 @@ import scala.language.implicitConversions
 object FQuote {
 
   implicit class SCOps(ctx: StringContext) {
-    inline def ff(args: => Any*): String = ~impl('(this), '(args))
+    inline def ff(args: => Any*): String = ${impl('this, 'args)}
   }
 
   /*private*/ def impl(receiver: Expr[SCOps], args: Expr[Seq[Any]])(implicit reflect: Reflection): Expr[String] = {
@@ -16,8 +16,8 @@ object FQuote {
       case x :: xs  =>
         val head = x.seal[Any]
         val tail = liftListOfAny(xs)
-        '{ ~head :: ~tail }
-      case Nil => '(Nil)
+        '{ $head :: $tail }
+      case Nil => '{Nil}
     }
 
     def isStringConstant(tree: Term) = tree match {
@@ -47,12 +47,12 @@ object FQuote {
 
     for ((arg, part) <- allArgs.zip(parts.tail)) {
       if (part.startsWith("%d") && !(arg.tpe <:< definitions.IntType)) {
-        return '(s"`${~arg.showCode.toExpr}` is not of type Int")
+        return '{s"`${${arg.showCode.toExpr}}` is not of type Int"}
       }
 
     }
 
     val string = parts.mkString("")
-    '{ new collection.immutable.StringOps(~string.toExpr).format(~args: _*) }
+    '{ new collection.immutable.StringOps(${string.toExpr}).format($args: _*) }
   }
 }
diff --git a/tests/run/gestalt-optional-staging/Macro_1.scala b/tests/run/gestalt-optional-staging/Macro_1.scala
index 74b2538782bc..005a85c95c31 100644
--- a/tests/run/gestalt-optional-staging/Macro_1.scala
+++ b/tests/run/gestalt-optional-staging/Macro_1.scala
@@ -7,9 +7,9 @@ final class Optional[+A >: Null](val value: A) extends AnyVal {
   def get: A = value
   def isEmpty = value == null
 
-  inline def getOrElse[B >: A](alt: => B): B = ~Optional.getOrElseImpl('(this), '(alt))
+  inline def getOrElse[B >: A](alt: => B): B = ${ Optional.getOrElseImpl('this, 'alt) }
 
-  inline def map[B >: Null](f: A => B): Optional[B] = ~Optional.mapImpl('(this), '(f))
+  inline def map[B >: Null](f: A => B): Optional[B] = ${ Optional.mapImpl('this, 'f) }
 
   override def toString = if (isEmpty) "<empty>" else s"$value"
 }
@@ -18,13 +18,13 @@ object Optional {
 
   // FIXME fix issue #5097 and enable private
   /*private*/ def getOrElseImpl[T >: Null : Type](opt: Expr[Optional[T]], alt: Expr[T]): Expr[T] = '{
-    if ((~opt).isEmpty) ~alt else (~opt).value
+    if ($opt.isEmpty) $alt else $opt.value
   }
 
   // FIXME fix issue #5097 and enable private
   /*private*/ def mapImpl[A >: Null : Type, B >: Null : Type](opt: Expr[Optional[A]], f: Expr[A => B]): Expr[Optional[B]] = '{
-    if ((~opt).isEmpty) new Optional(null)
-    else new Optional(~f('((~opt).value)))
+    if ($opt.isEmpty) new Optional(null)
+    else new Optional(${f('{$opt.value})})
   }
 
 }
diff --git a/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala b/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala
index 0eafbb998104..b66e6b987a3d 100644
--- a/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala
+++ b/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala
@@ -6,7 +6,7 @@ import scala.tasty._
 
 object TypeToolbox {
   /** are the two types equal? */
-  inline def =:=[A, B]: Boolean = ~tpEqImpl('[A], '[B])
+  inline def =:=[A, B]: Boolean = ${tpEqImpl('[A], '[B])}
   private def tpEqImpl[A, B](a: Type[A], b: Type[B])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
     val res = a.unseal.tpe =:= b.unseal.tpe
@@ -14,7 +14,7 @@ object TypeToolbox {
   }
 
   /** is `tp1` a subtype of `tp2` */
-  inline def <:<[A, B]: Boolean = ~tpLEqImpl('[A], '[B])
+  inline def <:<[A, B]: Boolean = ${tpLEqImpl('[A], '[B])}
   private def tpLEqImpl[A, B](a: Type[A], b: Type[B])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
     val res = a.unseal.tpe <:< b.unseal.tpe
@@ -22,7 +22,7 @@ object TypeToolbox {
   }
 
   /** type associated with the tree */
-  inline def typeOf[T, Expected](a: T): Boolean = ~typeOfImpl('(a), '[Expected])
+  inline def typeOf[T, Expected](a: T): Boolean = ${typeOfImpl('a, '[Expected])}
   private def typeOfImpl(a: Expr[_], expected: Type[_])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
     val res = a.unseal.tpe =:= expected.unseal.tpe
@@ -30,7 +30,7 @@ object TypeToolbox {
   }
 
   /** does the type refer to a case class? */
-  inline def isCaseClass[A]: Boolean = ~isCaseClassImpl('[A])
+  inline def isCaseClass[A]: Boolean = ${isCaseClassImpl('[A])}
   private def isCaseClassImpl(tp: Type[_])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
     val res = tp.unseal.symbol match {
@@ -41,66 +41,66 @@ object TypeToolbox {
   }
 
   /** val fields of a case class Type -- only the ones declared in primary constructor */
-  inline def caseFields[T]: List[String] = ~caseFieldsImpl('[T])
+  inline def caseFields[T]: List[String] = ${caseFieldsImpl('[T])}
   private def caseFieldsImpl(tp: Type[_])(implicit reflect: Reflection): Expr[List[String]] = {
     import reflect._
     val fields = tp.unseal.symbol.asClass.caseFields.map(_.name)
     fields.toExpr
   }
 
-  inline def fieldIn[T](inline mem: String): String = ~fieldInImpl('[T], mem)
+  inline def fieldIn[T](inline mem: String): String = ${fieldInImpl('[T], mem)}
   private def fieldInImpl(t: Type[_], mem: String)(implicit reflect: Reflection): Expr[String] = {
     import reflect._
     val field = t.unseal.symbol.asClass.field(mem)
     field.map(_.name).getOrElse("").toExpr
   }
 
-  inline def fieldsIn[T]: Seq[String] = ~fieldsInImpl('[T])
+  inline def fieldsIn[T]: Seq[String] = ${fieldsInImpl('[T])}
   private def fieldsInImpl(t: Type[_])(implicit reflect: Reflection): Expr[Seq[String]] = {
     import reflect._
     val fields = t.unseal.symbol.asClass.fields
     fields.map(_.name).toList.toExpr
   }
 
-  inline def methodIn[T](inline mem: String): Seq[String] = ~methodInImpl('[T], mem)
+  inline def methodIn[T](inline mem: String): Seq[String] = ${methodInImpl('[T], mem)}
   private def methodInImpl(t: Type[_], mem: String)(implicit reflect: Reflection): Expr[Seq[String]] = {
     import reflect._
     t.unseal.symbol.asClass.classMethod(mem).map(_.name).toExpr
   }
 
-  inline def methodsIn[T]: Seq[String] = ~methodsInImpl('[T])
+  inline def methodsIn[T]: Seq[String] = ${methodsInImpl('[T])}
   private def methodsInImpl(t: Type[_])(implicit reflect: Reflection): Expr[Seq[String]] = {
     import reflect._
     t.unseal.symbol.asClass.classMethods.map(_.name).toExpr
   }
 
-  inline def method[T](inline mem: String): Seq[String] = ~methodImpl('[T], mem)
+  inline def method[T](inline mem: String): Seq[String] = ${methodImpl('[T], mem)}
   private def methodImpl(t: Type[_], mem: String)(implicit reflect: Reflection): Expr[Seq[String]] = {
     import reflect._
     t.unseal.symbol.asClass.method(mem).map(_.name).toExpr
   }
 
-  inline def methods[T]: Seq[String] = ~methodsImpl('[T])
+  inline def methods[T]: Seq[String] = ${methodsImpl('[T])}
   private def methodsImpl(t: Type[_])(implicit reflect: Reflection): Expr[Seq[String]] = {
     import reflect._
     t.unseal.symbol.asClass.methods.map(_.name).toExpr
   }
 
-  inline def typeTag[T](x: T): String = ~typeTagImpl('[T])
+  inline def typeTag[T](x: T): String = ${typeTagImpl('[T])}
   private def typeTagImpl(tp: Type[_])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
     val res = tp.unseal.tpe.showCode
     res.toExpr
   }
 
-  inline def companion[T1, T2]: Boolean = ~companionImpl('[T1], '[T2])
+  inline def companion[T1, T2]: Boolean = ${companionImpl('[T1], '[T2])}
   private def companionImpl(t1: Type[_], t2: Type[_])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
     val res = t1.unseal.symbol.asClass.companionModule.contains(t2.unseal.symbol)
     res.toExpr
   }
 
-  inline def companionName[T1]: String = ~companionNameImpl('[T1])
+  inline def companionName[T1]: String = ${companionNameImpl('[T1])}
   private def companionNameImpl(tp: Type[_])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
     val companionClassOpt = tp.unseal.symbol match {
@@ -114,8 +114,8 @@ object TypeToolbox {
   // TODO add to the std lib
   private implicit def listIsLiftable[T: Type: Liftable]: Liftable[List[T]] = new Liftable {
     def toExpr(list: List[T]): Expr[List[T]] = list match {
-      case x :: xs => '(~x.toExpr :: ~toExpr(xs))
-      case Nil => '(Nil)
+      case x :: xs => '{${x.toExpr} :: ${toExpr(xs)}}
+      case Nil => '{Nil}
     }
   }
 }
diff --git a/tests/run/i4431/quoted_1.scala b/tests/run/i4431/quoted_1.scala
index 8f0be7b23ef7..245c60680cf7 100644
--- a/tests/run/i4431/quoted_1.scala
+++ b/tests/run/i4431/quoted_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 
 object Macros {
-  inline def h(f: => Int => String): String = ~ '(f(42))
+  inline def h(f: => Int => String): String = ${'{f(42)}}
 }
diff --git a/tests/run/i4455/Macro_1.scala b/tests/run/i4455/Macro_1.scala
index 9ac3070ed986..6ec8460328b1 100644
--- a/tests/run/i4455/Macro_1.scala
+++ b/tests/run/i4455/Macro_1.scala
@@ -1,8 +1,8 @@
 import scala.quoted._
 object Macros {
-  inline def foo(inline i: Int): Int = ~bar('(i))
+  inline def foo(inline i: Int): Int = ${ bar('i) }
 
-  inline def foo2(inline i: Int): Int = ~bar('(i + 1))
+  inline def foo2(inline i: Int): Int = ${ bar('{i + 1}) }
 
   def bar(x: Expr[Int]): Expr[Int] = x
 }
diff --git a/tests/run/i4492/quoted_1.scala b/tests/run/i4492/quoted_1.scala
index 67e68d59c1e7..8c4810cc3c43 100644
--- a/tests/run/i4492/quoted_1.scala
+++ b/tests/run/i4492/quoted_1.scala
@@ -2,5 +2,5 @@
 trait Index
 
 object Index {
-  inline def succ(prev: Index): Unit = ~{ '(println("Ok")) }
+  inline def succ(prev: Index): Unit = ${ '{println("Ok")} }
 }
diff --git a/tests/run/i4515/Macro_1.scala b/tests/run/i4515/Macro_1.scala
index f6fed9b178d3..b392bf410b57 100644
--- a/tests/run/i4515/Macro_1.scala
+++ b/tests/run/i4515/Macro_1.scala
@@ -1,5 +1,5 @@
 
 object Macro {
-  inline def foo[X](x: X): Unit = ~fooImpl('(x))
-  def fooImpl[X: quoted.Type](x: quoted.Expr[X]): quoted.Expr[Unit] = '()
+  inline def foo[X](x: X): Unit = ${fooImpl('x)}
+  def fooImpl[X: quoted.Type](x: quoted.Expr[X]): quoted.Expr[Unit] = '{}
 }
diff --git a/tests/run/i4515b/Macro_1.scala b/tests/run/i4515b/Macro_1.scala
index 176dc147ea08..ed345bd69bb5 100644
--- a/tests/run/i4515b/Macro_1.scala
+++ b/tests/run/i4515b/Macro_1.scala
@@ -1,6 +1,6 @@
 import scala.tasty.Reflection
 
 object Macro {
-  inline def foo: Unit = ~fooImpl
-  def fooImpl(implicit reflect: Reflection): quoted.Expr[Unit] = '()
+  inline def foo: Unit = ${ fooImpl }
+  def fooImpl(implicit reflect: Reflection): quoted.Expr[Unit] = '{}
 }
diff --git a/tests/run/i4734/Macro_1.scala b/tests/run/i4734/Macro_1.scala
index 5b4a90383bb8..361e14bc9cf3 100644
--- a/tests/run/i4734/Macro_1.scala
+++ b/tests/run/i4734/Macro_1.scala
@@ -3,21 +3,21 @@ import scala.quoted._
 
 object Macros {
   inline def unrolledForeach(seq: IndexedSeq[Int], f: => Int => Unit, inline unrollSize: Int): Unit = // or f: Int => Unit
-    ~unrolledForeachImpl('(seq), '(f), unrollSize)
+    ${ unrolledForeachImpl('seq, 'f, unrollSize) }
 
   def unrolledForeachImpl(seq: Expr[IndexedSeq[Int]], f: Expr[Int => Unit], unrollSize: Int): Expr[Unit] = '{
-    val size = (~seq).length
-    assert(size % (~unrollSize.toExpr) == 0) // for simplicity of the implementation
+    val size = ($seq).length
+    assert(size % (${unrollSize.toExpr}) == 0) // for simplicity of the implementation
     var i = 0
     while (i < size) {
-      ~{
+      ${
         for (j <- new UnrolledRange(0, unrollSize)) '{
-          val index = i + ~j.toExpr
-          val element = (~seq)(index)
-          ~f('(element)) // or `(~f)(element)` if `f` should not be inlined
+          val index = i + ${j.toExpr}
+          val element = ($seq)(index)
+          ${ f('element) } // or `($f)(element)` if `f` should not be inlined
         }
       }
-      i += ~unrollSize.toExpr
+      i += ${unrollSize.toExpr}
     }
 
   }
@@ -25,9 +25,9 @@ object Macros {
   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 })
+        if (i >= 0) loop(i - 1, '{ ${f(i)}; $acc })
       else acc
-      loop(end - 1, '())
+      loop(end - 1, '{})
     }
   }
 }
diff --git a/tests/run/i4735/Macro_1.scala b/tests/run/i4735/Macro_1.scala
index 2a7aabc6db47..3a56c8dfa218 100644
--- a/tests/run/i4735/Macro_1.scala
+++ b/tests/run/i4735/Macro_1.scala
@@ -4,21 +4,21 @@ import scala.quoted._
 object Macro {
 
   inline def unrolledForeach(inline unrollSize: Int, seq: Array[Int], f: => Int => Unit): Unit = // or f: Int => Unit
-    ~unrolledForeachImpl(unrollSize, '(seq), '(f))
+    ${ 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
+    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
+          val element = ($seq)(i + ${j.toExpr})
+          ${f('element)} // or `($f)(element)` if `f` should not be inlined
         }
       }
-      i += ~unrollSize.toExpr
+      i += ${unrollSize.toExpr}
     }
 
   }
@@ -26,9 +26,9 @@ object Macro {
   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 })
+        if (i >= 0) loop(i - 1, '{ ${f(i)}; $acc })
       else acc
-      loop(end - 1, '())
+      loop(end - 1, '{})
     }
   }
 }
diff --git a/tests/run/i4803/App_2.scala b/tests/run/i4803/App_2.scala
index 703fbf871457..ed7f5caaecae 100644
--- a/tests/run/i4803/App_2.scala
+++ b/tests/run/i4803/App_2.scala
@@ -1,6 +1,6 @@
 
 class Num2(x: Double) {
-  inline def power(inline n: Long) = ~PowerMacro.powerCode('(x), n)
+  inline def power(inline n: Long) = ${ PowerMacro.powerCode('x, n) }
 }
 
 object Test {
diff --git a/tests/run/i4803/Macro_1.scala b/tests/run/i4803/Macro_1.scala
index 46cd0e925c7b..9e1455107699 100644
--- a/tests/run/i4803/Macro_1.scala
+++ b/tests/run/i4803/Macro_1.scala
@@ -2,11 +2,11 @@ import scala.quoted._
 
 object PowerMacro {
   def powerCode(x: Expr[Double], n: Long): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode('(y), n / 2) }
-    else '{ ~x * ~powerCode(x, n - 1) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ val y = $x * $x; ${ powerCode('y, n / 2) } }
+    else '{ $x * ${ powerCode(x, n - 1) } }
 }
 
 class Num(x: Double) {
-  inline def power(inline n: Long) = ~PowerMacro.powerCode('(x), n)
+  inline def power(inline n: Long) = ${ PowerMacro.powerCode('x, n) }
 }
diff --git a/tests/run/i4803b/App_2.scala b/tests/run/i4803b/App_2.scala
index 698885b5b54f..ab3fe67df501 100644
--- a/tests/run/i4803b/App_2.scala
+++ b/tests/run/i4803b/App_2.scala
@@ -2,7 +2,7 @@
 
 class Nums {
   class Num(x: Double) {
-    inline def power(inline n: Long) = ~PowerMacro.powerCode('(x), n)
+    inline def power(inline n: Long) = ${ PowerMacro.powerCode('x, n) }
   }
 }
 
diff --git a/tests/run/i4803b/Macro_1.scala b/tests/run/i4803b/Macro_1.scala
index 681f3b2fac63..48eab25d259b 100644
--- a/tests/run/i4803b/Macro_1.scala
+++ b/tests/run/i4803b/Macro_1.scala
@@ -2,7 +2,7 @@ import scala.quoted._
 
 object PowerMacro {
   def powerCode(x: Expr[Double], n: Long): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode('(y), n / 2) }
-    else '{ ~x * ~powerCode(x, n - 1) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ val y = $x * $x; ${ powerCode('y, n / 2) } }
+    else '{ $x * ${ powerCode(x, n - 1) } }
 }
diff --git a/tests/run/i4803c/App_2.scala b/tests/run/i4803c/App_2.scala
index 128fcfb19600..953e4a983999 100644
--- a/tests/run/i4803c/App_2.scala
+++ b/tests/run/i4803c/App_2.scala
@@ -2,7 +2,7 @@
 object Test {
   def main(args: Array[String]): Unit = {
     class Num(x: Double) {
-      inline def power(inline n: Long) = ~PowerMacro.powerCode('(x), n)
+      inline def power(inline n: Long) = ${ PowerMacro.powerCode('x, n) }
     }
     val n = new Num(1.5)
     println(n.power(0))
@@ -10,7 +10,7 @@ object Test {
     println(n.power(2))
     println(n.power(5))
 
-    inline def power(x: Double, inline n: Long) = ~PowerMacro.powerCode('(x), n)
+    inline def power(x: Double, inline n: Long) = ${ PowerMacro.powerCode('x, n) }
 
     val x: Double = 1.5
 
diff --git a/tests/run/i4803c/Macro_1.scala b/tests/run/i4803c/Macro_1.scala
index 681f3b2fac63..8070c3180721 100644
--- a/tests/run/i4803c/Macro_1.scala
+++ b/tests/run/i4803c/Macro_1.scala
@@ -2,7 +2,7 @@ import scala.quoted._
 
 object PowerMacro {
   def powerCode(x: Expr[Double], n: Long): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode('(y), n / 2) }
-    else '{ ~x * ~powerCode(x, n - 1) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ val y = $x * $x; ${powerCode('y, n / 2)} }
+    else '{ $x * ${powerCode(x, n - 1)} }
 }
diff --git a/tests/run/i4803e/App_2.scala b/tests/run/i4803e/App_2.scala
index 224df7eabb0d..bd5dcd5c1360 100644
--- a/tests/run/i4803e/App_2.scala
+++ b/tests/run/i4803e/App_2.scala
@@ -10,5 +10,5 @@ object Test {
     println(power2(x3))
   }
 
-  inline def power2(x: Double) = ~PowerMacro.power2('(x))
+  inline def power2(x: Double) = ${PowerMacro.power2('x)}
 }
diff --git a/tests/run/i4803e/Macro_1.scala b/tests/run/i4803e/Macro_1.scala
index f4392c41a3b1..4ccfa8c0e0f4 100644
--- a/tests/run/i4803e/Macro_1.scala
+++ b/tests/run/i4803e/Macro_1.scala
@@ -6,6 +6,6 @@ object PowerMacro {
       if (n == 0) 1.0
       else if (n % 2 == 0) { val y = x * x; power(y, n / 2) }
       else x * power(x, n - 1)
-    power(~x, 2)
+    power($x, 2)
   }
 }
diff --git a/tests/run/i4803f/App_2.scala b/tests/run/i4803f/App_2.scala
index 224df7eabb0d..bd5dcd5c1360 100644
--- a/tests/run/i4803f/App_2.scala
+++ b/tests/run/i4803f/App_2.scala
@@ -10,5 +10,5 @@ object Test {
     println(power2(x3))
   }
 
-  inline def power2(x: Double) = ~PowerMacro.power2('(x))
+  inline def power2(x: Double) = ${PowerMacro.power2('x)}
 }
diff --git a/tests/run/i4803f/Macro_1.scala b/tests/run/i4803f/Macro_1.scala
index dd693322b62d..25aee2bf00c7 100644
--- a/tests/run/i4803f/Macro_1.scala
+++ b/tests/run/i4803f/Macro_1.scala
@@ -2,12 +2,12 @@ import scala.quoted._
 
 object PowerMacro {
   def powerCode(x: Expr[Double], n: Long): Expr[Double] =
-    if (n == 0) '(1.0)
-    else if (n % 2 == 0) '{ val y = ~x * ~x; ~powerCode('(y), n / 2) }
-    else '{ ~x * ~powerCode(x, n - 1) }
+    if (n == 0) '{1.0}
+    else if (n % 2 == 0) '{ val y = $x * $x; ${powerCode('y, n / 2)} }
+    else '{ $x * ${powerCode(x, n - 1)} }
 
   def power2(x: Expr[Double]) = '{
-    inline def power(x: Double): Double = ~powerCode('(x), 2)
-    power(~x)
+    inline def power(x: Double): Double = ${powerCode('x, 2)}
+    power($x)
   }
 }
diff --git a/tests/run/i4947e/Macro_1.scala b/tests/run/i4947e/Macro_1.scala
index 175a642be819..7e08adf6d076 100644
--- a/tests/run/i4947e/Macro_1.scala
+++ b/tests/run/i4947e/Macro_1.scala
@@ -6,6 +6,6 @@ object Macros {
   }
   def assertImpl(expr: Expr[Boolean]) = '{
     printStack("assertImpl")
-    println(~expr)
+    println($expr)
   }
 }
diff --git a/tests/run/i4947e/Test_2.scala b/tests/run/i4947e/Test_2.scala
index cc83cd4b4536..13af75fd5009 100644
--- a/tests/run/i4947e/Test_2.scala
+++ b/tests/run/i4947e/Test_2.scala
@@ -1,6 +1,6 @@
 object Test {
 
-  inline def assert2(expr: => Boolean): Unit =  ~Macros.assertImpl('(expr))
+  inline def assert2(expr: => Boolean): Unit = ${ Macros.assertImpl('expr) }
 
   def main(args: Array[String]): Unit = {
     val x = 1
diff --git a/tests/run/i4947f/Macro_1.scala b/tests/run/i4947f/Macro_1.scala
index c18b3c0a7eba..acbf4f25f5a8 100644
--- a/tests/run/i4947f/Macro_1.scala
+++ b/tests/run/i4947f/Macro_1.scala
@@ -6,9 +6,9 @@ object Macros {
   }
   def assertImpl(expr: Expr[Boolean]) = '{
     printStack("assertImpl")
-    println(~expr)
+    println($expr)
   }
 
-  inline def assert2(expr: => Boolean): Unit =  ~Macros.assertImpl('(expr))
+  inline def assert2(expr: => Boolean): Unit = ${ Macros.assertImpl('expr) }
 
 }
diff --git a/tests/run/i5119/Macro_1.scala b/tests/run/i5119/Macro_1.scala
index c0be1daf8560..9c187561aead 100644
--- a/tests/run/i5119/Macro_1.scala
+++ b/tests/run/i5119/Macro_1.scala
@@ -3,7 +3,7 @@ import scala.tasty.Reflection
 
 object Macro {
   class StringContextOps(sc: => StringContext) {
-    inline def ff(args: => Any*): String = ~Macro.impl('(sc), '(args))
+    inline def ff(args: => Any*): String = ${ Macro.impl('sc, 'args) }
   }
   implicit inline def XmlQuote(sc: => StringContext): StringContextOps = new StringContextOps(sc)
   def impl(sc: Expr[StringContext], args: Expr[Seq[Any]])(implicit reflect: Reflection): Expr[String] = {
diff --git a/tests/run/i5119b/Macro_1.scala b/tests/run/i5119b/Macro_1.scala
index e2be2b6fb147..31dfb675a15b 100644
--- a/tests/run/i5119b/Macro_1.scala
+++ b/tests/run/i5119b/Macro_1.scala
@@ -3,7 +3,7 @@ import scala.tasty.Reflection
 
 object Macro {
 
-  inline def ff(arg1: Any,  arg2: Any): String = ~Macro.impl('(arg1), '(arg2))
+  inline def ff(arg1: Any,  arg2: Any): String = ${ Macro.impl('{arg1}, '{arg2}) }
 
   def impl(arg1: Expr[Any], arg2: Expr[Any])(implicit reflect: Reflection): Expr[String] = {
     import reflect._
diff --git a/tests/run/i5188a/Macro_1.scala b/tests/run/i5188a/Macro_1.scala
index 77f6183df67c..7c6e2c716143 100644
--- a/tests/run/i5188a/Macro_1.scala
+++ b/tests/run/i5188a/Macro_1.scala
@@ -1,6 +1,6 @@
 import scala.quoted._
 
 object Lib {
-  inline def sum(inline args: Int*): Int = ~impl(args: _*)
+  inline def sum(inline args: Int*): Int = ${ impl(args: _*) }
   def impl(args: Int*): Expr[Int] = args.sum.toExpr
 }
diff --git a/tests/run/i5386.check b/tests/run/i5386.check
index 343e36be2164..6d4e249851c1 100644
--- a/tests/run/i5386.check
+++ b/tests/run/i5386.check
@@ -1,7 +1,6 @@
 !
 !
 !
-!
 1
 2
 !
diff --git a/tests/run/i5386.scala b/tests/run/i5386.scala
index eff28a2601f9..a1718a2dc0f3 100644
--- a/tests/run/i5386.scala
+++ b/tests/run/i5386.scala
@@ -1,10 +1,5 @@
 object Test extends App {
 
-  ~{
-    println("!")
-    1
-  }
-
   +{
     println("!")
     1
diff --git a/tests/run/i5533/Macro_1.scala b/tests/run/i5533/Macro_1.scala
index 05552fcc7513..f4b58630cebf 100644
--- a/tests/run/i5533/Macro_1.scala
+++ b/tests/run/i5533/Macro_1.scala
@@ -6,7 +6,7 @@ object scalatest {
   def f(x: Int): Boolean = false
   def f(x: String): Boolean = true
 
-  inline def assert(condition: => Boolean): Unit = ~assertImpl('(condition))
+  inline def assert(condition: => Boolean): Unit = ${assertImpl('condition)}
 
   def assertImpl(condition: Expr[Boolean])(implicit refl: Reflection): Expr[Unit] = {
     import refl._
@@ -15,6 +15,6 @@ object scalatest {
 
     val expr = tree.seal[Boolean]
 
-    '(println(~expr))
+    '{println($expr)}
   }
 }
diff --git a/tests/run/i5533b/Macro_1.scala b/tests/run/i5533b/Macro_1.scala
index ad63176aa2cd..8c5afb167c15 100644
--- a/tests/run/i5533b/Macro_1.scala
+++ b/tests/run/i5533b/Macro_1.scala
@@ -5,7 +5,7 @@ object scalatest {
   def f(x: Int): Int = x
   def f(x: String): String = x
 
-  inline def assert(condition: => Boolean): Unit = ~assertImpl('(condition))
+  inline def assert(condition: => Boolean): Unit = ${assertImpl('condition)}
 
   def assertImpl(condition: Expr[Boolean])(implicit refl: Reflection): Expr[Unit] = {
     import refl._
@@ -21,8 +21,8 @@ object scalatest {
         op match {
           case "==" =>
         '{
-          val _left   = ~left
-          val _right  = ~right
+          val _left   = $left
+          val _right  = $right
           val _result = _left == _right
           println(_left)
           println(_right)
diff --git a/tests/run/i5536/Macro_1.scala b/tests/run/i5536/Macro_1.scala
index 58e986cad5e7..0fe7e9778637 100644
--- a/tests/run/i5536/Macro_1.scala
+++ b/tests/run/i5536/Macro_1.scala
@@ -2,7 +2,7 @@ import scala.quoted._
 import scala.tasty._
 
 object scalatest {
-  inline def assert(condition: => Boolean): Unit = ~assertImpl('(condition))
+  inline def assert(condition: => Boolean): Unit = ${assertImpl('condition)}
 
   def assertImpl(condition: Expr[Boolean])(implicit refl: Reflection): Expr[Unit] = {
     import refl._
@@ -18,8 +18,8 @@ object scalatest {
         op match {
           case "===" =>
             '{
-              val _left   = ~left
-              val _right  = ~right
+              val _left   = $left
+              val _right  = $right
               val _result = _left == _right
               scala.Predef.assert(_result)
             }
diff --git a/tests/run/i5606.scala b/tests/run/i5606.scala
index 8bbad0138813..a7b9fc340b60 100644
--- a/tests/run/i5606.scala
+++ b/tests/run/i5606.scala
@@ -1,14 +1,14 @@
 object Test extends App {
 
-  def (f: A => B) $[A, B](a: A): B = f(a)
+  def (f: A => B) `$`[A, B](a: A): B = f(a)
 
-  assert((((a: Int) => a.toString()) $ 10) == "10")
+  assert((((a: Int) => a.toString()) `$` 10) == "10")
 
   def g(x: Int): String = x.toString
 
-  assert((g $ 10) == "10")
+  assert((g `$` 10) == "10")
 
   val h: Int => String = _.toString
 
-  assert((h $ 10) == "10")
+  assert((h `$` 10) == "10")
 }
diff --git a/tests/run/inline-case-objects/Main_2.scala b/tests/run/inline-case-objects/Main_2.scala
index 7f03be8a15c4..170efdebcc6a 100644
--- a/tests/run/inline-case-objects/Main_2.scala
+++ b/tests/run/inline-case-objects/Main_2.scala
@@ -10,6 +10,6 @@ object Test {
     println(fooString(foo.Bar.Baz))
   }
 
-  inline def fooString(inline x: Any): String = ~Macros.impl(x)
+  inline def fooString(inline x: Any): String = ${Macros.impl(x)}
 
 }
diff --git a/tests/run/inline-macro-staged-interpreter/Macro_1.scala b/tests/run/inline-macro-staged-interpreter/Macro_1.scala
index 11bdd3533e00..6d4948f691a4 100644
--- a/tests/run/inline-macro-staged-interpreter/Macro_1.scala
+++ b/tests/run/inline-macro-staged-interpreter/Macro_1.scala
@@ -3,7 +3,7 @@ import scala.quoted._
 
 object E {
 
-  inline def eval[T](inline x: E[T]): T = ~impl(x)
+  inline def eval[T](inline x: E[T]): T = ${ impl(x) }
 
   def impl[T](x: E[T]): Expr[T] = x.lift
 
@@ -36,21 +36,21 @@ trait Op2[T] {
 trait Plus2[T] extends Op2[T]
 object Plus2 {
   implicit case object IPlus extends Plus2[Int] {
-    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '(~x + ~y)
+    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '{$x + $y}
   }
 
   implicit case object DPlus extends Plus2[Double] {
-    def apply(x: Expr[Double], y: Expr[Double]): Expr[Double] = '(~x + ~y)
+    def apply(x: Expr[Double], y: Expr[Double]): Expr[Double] = '{$x + $y}
   }
 }
 
 trait Times2[T] extends Op2[T]
 object Times2 {
   implicit case object ITimes extends Times2[Int] {
-    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '(~x * ~y)
+    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '{$x * $y}
   }
 
   implicit case object DTimes extends Times2[Double] {
-    def apply(x: Expr[Double], y: Expr[Double]): Expr[Double] = '(~x * ~y)
+    def apply(x: Expr[Double], y: Expr[Double]): Expr[Double] = '{$x * $y}
   }
 }
diff --git a/tests/run/inline-option/Macro_1.scala b/tests/run/inline-option/Macro_1.scala
index 6f278bcf5403..59f5f8f3f9ea 100644
--- a/tests/run/inline-option/Macro_1.scala
+++ b/tests/run/inline-option/Macro_1.scala
@@ -5,7 +5,7 @@ object Macros {
 
   def impl(opt: Option[Int]): Expr[Int] = opt match {
     case Some(i) => i.toExpr
-    case None => '(-1)
+    case None => '{-1}
   }
 
   def impl2(opt: Option[Option[Int]]): Expr[Int] = impl(opt.flatten)
diff --git a/tests/run/inline-option/Main_2.scala b/tests/run/inline-option/Main_2.scala
index 0050e2bdf89e..915678b9c54e 100644
--- a/tests/run/inline-option/Main_2.scala
+++ b/tests/run/inline-option/Main_2.scala
@@ -15,14 +15,14 @@ object Test {
     println(size5(Some(Some(6))))
   }
 
-  inline def size(inline opt: Option[Int]): Int = ~Macros.impl(opt)
+  inline def size(inline opt: Option[Int]): Int = ${ Macros.impl(opt) }
 
-  inline def size2(inline i: Int): Int = ~Macros.impl(None)
+  inline def size2(inline i: Int): Int = ${ Macros.impl(None) }
 
-  inline def size3(inline i: Int): Int = ~Macros.impl(Some(i))
+  inline def size3(inline i: Int): Int = ${ Macros.impl(Some(i)) }
 
-  inline def size4(inline i: Int): Int = ~Macros.impl2(Some(Some(i)))
+  inline def size4(inline i: Int): Int = ${ Macros.impl2(Some(Some(i))) }
 
-  inline def size5(inline opt: Option[Option[Int]]): Int = ~Macros.impl2(opt)
+  inline def size5(inline opt: Option[Option[Int]]): Int = ${ Macros.impl2(opt) }
 
 }
diff --git a/tests/run/inline-tuples-1/Main_2.scala b/tests/run/inline-tuples-1/Main_2.scala
index 54971154d29e..13ba486a6ed5 100644
--- a/tests/run/inline-tuples-1/Main_2.scala
+++ b/tests/run/inline-tuples-1/Main_2.scala
@@ -26,27 +26,27 @@ object Test {
     println(sum(Tuple22(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)))
   }
 
-  inline def sum(inline tup: Tuple1[Int]): Int = ~Macros.tup1(tup)
-  inline def sum(inline tup: Tuple2[Int, Int]): Int = ~Macros.tup2(tup)
-  inline def sum(inline tup: Tuple3[Int, Int, Int]): Int = ~Macros.tup3(tup)
-  inline def sum(inline tup: Tuple4[Int, Int, Int, Int]): Int = ~Macros.tup4(tup)
-  inline def sum(inline tup: Tuple5[Int, Int, Int, Int, Int]): Int = ~Macros.tup5(tup)
-  inline def sum(inline tup: Tuple6[Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup6(tup)
-  inline def sum(inline tup: Tuple7[Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup7(tup)
-  inline def sum(inline tup: Tuple8[Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup8(tup)
-  inline def sum(inline tup: Tuple9[Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup9(tup)
-  inline def sum(inline tup: Tuple10[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup10(tup)
-  inline def sum(inline tup: Tuple11[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup11(tup)
-  inline def sum(inline tup: Tuple12[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup12(tup)
-  inline def sum(inline tup: Tuple13[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup13(tup)
-  inline def sum(inline tup: Tuple14[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup14(tup)
-  inline def sum(inline tup: Tuple15[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup15(tup)
-  inline def sum(inline tup: Tuple16[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup16(tup)
-  inline def sum(inline tup: Tuple17[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup17(tup)
-  inline def sum(inline tup: Tuple18[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup18(tup)
-  inline def sum(inline tup: Tuple19[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup19(tup)
-  inline def sum(inline tup: Tuple20[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup20(tup)
-  inline def sum(inline tup: Tuple21[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup21(tup)
-  inline def sum(inline tup: Tuple22[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ~Macros.tup22(tup)
+  inline def sum(inline tup: Tuple1[Int]): Int = ${ Macros.tup1(tup) }
+  inline def sum(inline tup: Tuple2[Int, Int]): Int = ${ Macros.tup2(tup) }
+  inline def sum(inline tup: Tuple3[Int, Int, Int]): Int = ${ Macros.tup3(tup) }
+  inline def sum(inline tup: Tuple4[Int, Int, Int, Int]): Int = ${ Macros.tup4(tup) }
+  inline def sum(inline tup: Tuple5[Int, Int, Int, Int, Int]): Int = ${ Macros.tup5(tup) }
+  inline def sum(inline tup: Tuple6[Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup6(tup) }
+  inline def sum(inline tup: Tuple7[Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup7(tup) }
+  inline def sum(inline tup: Tuple8[Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup8(tup) }
+  inline def sum(inline tup: Tuple9[Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup9(tup) }
+  inline def sum(inline tup: Tuple10[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup10(tup) }
+  inline def sum(inline tup: Tuple11[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup11(tup) }
+  inline def sum(inline tup: Tuple12[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup12(tup) }
+  inline def sum(inline tup: Tuple13[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup13(tup) }
+  inline def sum(inline tup: Tuple14[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup14(tup) }
+  inline def sum(inline tup: Tuple15[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup15(tup) }
+  inline def sum(inline tup: Tuple16[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup16(tup) }
+  inline def sum(inline tup: Tuple17[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup17(tup) }
+  inline def sum(inline tup: Tuple18[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup18(tup) }
+  inline def sum(inline tup: Tuple19[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup19(tup) }
+  inline def sum(inline tup: Tuple20[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup20(tup) }
+  inline def sum(inline tup: Tuple21[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup21(tup) }
+  inline def sum(inline tup: Tuple22[Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int]): Int = ${ Macros.tup22(tup) }
 
 }
diff --git a/tests/run/inline-tuples-2/Main_2.scala b/tests/run/inline-tuples-2/Main_2.scala
index d250d919f941..7e29333e8bfb 100644
--- a/tests/run/inline-tuples-2/Main_2.scala
+++ b/tests/run/inline-tuples-2/Main_2.scala
@@ -11,12 +11,12 @@ object Test {
     println(get4(Tuple1(Tuple1(6))))
   }
 
-  inline def get1(inline tup: Tuple1[Int]): Int = ~Macros.impl(tup)
+  inline def get1(inline tup: Tuple1[Int]): Int = ${ Macros.impl(tup) }
 
-  inline def get2(inline i: Int): Int = ~Macros.impl(Tuple1(i))
+  inline def get2(inline i: Int): Int = ${ Macros.impl(Tuple1(i)) }
 
-  inline def get3(inline i: Int): Int = ~Macros.impl2(Tuple1(Tuple1(i)))
+  inline def get3(inline i: Int): Int = ${ Macros.impl2(Tuple1(Tuple1(i))) }
 
-  inline def get4(inline tup: Tuple1[Tuple1[Int]]): Int = ~Macros.impl2(tup)
+  inline def get4(inline tup: Tuple1[Tuple1[Int]]): Int = ${ Macros.impl2(tup) }
 
 }
diff --git a/tests/run/inline-varargs-1/Main_2.scala b/tests/run/inline-varargs-1/Main_2.scala
index 95edcdf19a8d..16b90860dd7c 100644
--- a/tests/run/inline-varargs-1/Main_2.scala
+++ b/tests/run/inline-varargs-1/Main_2.scala
@@ -5,5 +5,5 @@ object Test {
     println(sum(1, 2, 3))
   }
 
-  inline def sum(inline i: Int, inline j: Int, inline k: Int): Int = ~Macros.sum(i, j, k)
+  inline def sum(inline i: Int, inline j: Int, inline k: Int): Int = ${ Macros.sum(i, j, k) }
 }
diff --git a/tests/run/quote-and-splice/Macros_1.scala b/tests/run/quote-and-splice/Macros_1.scala
index ef3706464b41..f74d33359bf4 100644
--- a/tests/run/quote-and-splice/Macros_1.scala
+++ b/tests/run/quote-and-splice/Macros_1.scala
@@ -2,26 +2,26 @@ import scala.quoted._
 
 object Macros {
 
-  inline def macro1 = ~ macro1Impl
-  def macro1Impl = '(3)
+  inline def macro1 = ${ macro1Impl }
+  def macro1Impl = '{3}
 
-  inline def macro2(inline p: Boolean) = ~ macro2Impl(p)
-  def macro2Impl(p: Boolean) = if (p) '(3) else '(4)
+  inline def macro2(inline p: Boolean) = ${ macro2Impl(p) }
+  def macro2Impl(p: Boolean) = if (p) '{3} else '{4}
 
-  inline def macro3(n: Int) = ~ macro3Impl('(n))
-  def macro3Impl(p: Expr[Int]) = '{ 2 + ~p }
+  inline def macro3(n: Int) = ${ macro3Impl('n) }
+  def macro3Impl(p: Expr[Int]) = '{ 2 + $p }
 
-  inline def macro4(i: Int)(j: Int) = ~ macro4Impl('(i))('(j))
-  def macro4Impl(i: Expr[Int])(j: Expr[Int]) = '{ ~i + ~j }
+  inline def macro4(i: Int)(j: Int) = ${ macro4Impl('i)('j) }
+  def macro4Impl(i: Expr[Int])(j: Expr[Int]) = '{ $i + $j }
 
-  inline def macro5(i: Int, j: Int) = ~ macro5Impl(j = '(j), i = '(i))
-  def macro5Impl(i: Expr[Int], j: Expr[Int]) = '{ ~i + ~j }
+  inline def macro5(i: Int, j: Int) = ${ macro5Impl(j = 'j, i = 'i) }
+  def macro5Impl(i: Expr[Int], j: Expr[Int]) = '{ $i + $j }
 
-  inline def power(inline n: Int, x: Double) = ~powerCode(n, '(x))
+  inline def power(inline n: Int, x: Double) = ${ powerCode(n, 'x) }
 
   def powerCode(n: Int, x: Expr[Double]): Expr[Double] =
-    if (n == 0) '(1.0)
+    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 % 2 == 0) '{ { val y = $x * $x; ${powerCode(n / 2, 'y)} } }
+    else '{ $x * ${ powerCode(n - 1, x) } }
 }
diff --git a/tests/run/quote-change-owner/Macro_1.scala b/tests/run/quote-change-owner/Macro_1.scala
index 7ae01816db48..c388edf03f14 100644
--- a/tests/run/quote-change-owner/Macro_1.scala
+++ b/tests/run/quote-change-owner/Macro_1.scala
@@ -1,8 +1,8 @@
 import scala.quoted._
 object Macros {
-  inline def assert2(expr: => Boolean): Unit =  ~ assertImpl('(expr))
+  inline def assert2(expr: => Boolean): Unit =  ${ assertImpl('expr) }
   def assertImpl(expr: Expr[Boolean]) = '{
-    def foo(): Unit = ~expr
+    def foo(): Unit = $expr
     foo()
   }
 }
diff --git a/tests/run/quote-compile-constants.scala b/tests/run/quote-compile-constants.scala
index bcf98ff0f88b..9fd8a478f82c 100644
--- a/tests/run/quote-compile-constants.scala
+++ b/tests/run/quote-compile-constants.scala
@@ -2,19 +2,19 @@ import scala.quoted._
 
 object Test {
   def main(args: Array[String]): Unit = {
-    println(('(true)).getClass)
+    println(('{true}).getClass)
     println(('{ 'a' }).getClass)
     println(('{ '\n' }).getClass)
     println(('{ '"' }).getClass)
     println(('{ '\'' }).getClass)
     println(('{ '\\' }).getClass)
-    println(('(1)).getClass)
-    println(('( { { 2 } } )).getClass)
-    println(('(3L)).getClass)
-    println(('(4.0f)).getClass)
-    println(('(5.0d)).getClass)
-    println(('("xyz")).getClass)
-    println(('()).getClass)
+    println(('{1}).getClass)
+    println(('{ { { 2 } } }).getClass)
+    println(('{3L}).getClass)
+    println(('{4.0f}).getClass)
+    println(('{5.0d}).getClass)
+    println(('{"xyz"}).getClass)
+    println(('{}).getClass)
     println(('{()}).getClass)
     println(('{{()}}).getClass)
   }
diff --git a/tests/run/quote-force/quoted_1.scala b/tests/run/quote-force/quoted_1.scala
index 47c01a3c3abf..24f235074b82 100644
--- a/tests/run/quote-force/quoted_1.scala
+++ b/tests/run/quote-force/quoted_1.scala
@@ -4,15 +4,15 @@ case class Location(owners: List[String])
 
 object Location {
 
-  implicit inline def location: Location = ~impl
+  implicit inline def location: Location = ${impl}
 
   def impl: Expr[Location] = {
     val list = List("a", "b", "c", "d", "e", "f")
-    '(new Location(~list.toExpr))
+    '{new Location(${list.toExpr})}
   }
 
   private implicit def ListIsLiftable[T : Liftable : Type]: Liftable[List[T]] = {
-    case x :: xs  => '{ ~x.toExpr :: ~xs.toExpr }
+    case x :: xs  => '{ ${x.toExpr} :: ${xs.toExpr} }
     case Nil => '{ List.empty[T] }
   }
 }
diff --git a/tests/run/quote-indexed-map-by-name/quoted_1.scala b/tests/run/quote-indexed-map-by-name/quoted_1.scala
index 32ed34bac0e6..5696310081b5 100644
--- a/tests/run/quote-indexed-map-by-name/quoted_1.scala
+++ b/tests/run/quote-indexed-map-by-name/quoted_1.scala
@@ -5,9 +5,9 @@ object Index {
 
   implicit def zero[K, T]: Index[K, (K, T)] = new Index(0)
 
-  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ~succImpl('[K], '[H], '[T])
+  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ${succImpl('[K], '[H], '[T])}
 
   def succImpl[K, H, T](implicit k: Type[K], h: Type[H], t: Type[T]): Expr[Index[K, (H, T)]] = {
-    '(new Index(0))
+    '{new Index(0)}
   }
 }
\ No newline at end of file
diff --git a/tests/run/quote-sep-comp-2/Macro_1.scala b/tests/run/quote-sep-comp-2/Macro_1.scala
index dadd4d890a99..eac46498d15f 100644
--- a/tests/run/quote-sep-comp-2/Macro_1.scala
+++ b/tests/run/quote-sep-comp-2/Macro_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 
 object Macros {
-  def assertImpl(expr: Expr[Boolean]) = '{ println(~expr) }
+  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
index 30be33cad19c..35f9d2cc134e 100644
--- a/tests/run/quote-sep-comp-2/Test_2.scala
+++ b/tests/run/quote-sep-comp-2/Test_2.scala
@@ -1,7 +1,7 @@
 
 object Test {
 
-  inline def assert2(expr: => Boolean): Unit =  ~Macros.assertImpl('(expr))
+  inline def assert2(expr: => Boolean): Unit =  ${ Macros.assertImpl('expr) }
 
   def main(args: Array[String]): Unit = {
     val x = 1
diff --git a/tests/run/quote-sep-comp/Macro_1.scala b/tests/run/quote-sep-comp/Macro_1.scala
index c3ce7e2e1d53..e13342ac0dc8 100644
--- a/tests/run/quote-sep-comp/Macro_1.scala
+++ b/tests/run/quote-sep-comp/Macro_1.scala
@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macros {
-  inline def assert2(expr: => Boolean): Unit =  ~ assertImpl('(expr))
-  def assertImpl(expr: Expr[Boolean]) = '{ println(~expr) }
+  inline def assert2(expr: => Boolean): Unit =  ${ assertImpl('expr) }
+  def assertImpl(expr: Expr[Boolean]) = '{ println($expr) }
 }
diff --git a/tests/run/quote-simple-hole.scala b/tests/run/quote-simple-hole.scala
index 2fcb905abc3e..5bfcf0ac45cd 100644
--- a/tests/run/quote-simple-hole.scala
+++ b/tests/run/quote-simple-hole.scala
@@ -1,13 +1,17 @@
 object Test {
   def main(args: Array[String]): Unit = {
-    val x = '(0)
-    val y = '(~x)
-    val z = '(~('(~y)))
+    val x = '{0}
+    val y = '{$x}
+    val z = '{${'{$y}}}
+    val a = '{{{$x}}}
+    val b = '{{${{'{{$y}}}}}}
     assert(x eq y)
     assert(x eq z)
+    assert(x eq a)
+    assert(x eq b)
 
     val i = '[Int]
-    val j = '[~i]
+    val j = '[$i]
     assert(i eq j)
   }
 }
diff --git a/tests/run/quote-simple-macro/quoted_1.scala b/tests/run/quote-simple-macro/quoted_1.scala
index 9f3dbea2f0c5..66e974d9702e 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 {
-  inline def foo(inline i: Int, dummy: Int, j: Int): Int = ~bar(i, '(j))
-  def bar(x: Int, y: Expr[Int]): Expr[Int] = '{ ~x.toExpr + ~y }
+  inline def foo(inline 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/quote-unrolled-foreach/quoted_1.scala b/tests/run/quote-unrolled-foreach/quoted_1.scala
index 0f1ac1d3599a..eecf8e094414 100644
--- a/tests/run/quote-unrolled-foreach/quoted_1.scala
+++ b/tests/run/quote-unrolled-foreach/quoted_1.scala
@@ -4,21 +4,21 @@ import scala.quoted._
 object Macro {
 
   inline def unrolledForeach(inline unrollSize: Int, seq: Array[Int])(f: => Int => Unit): Unit = // or f: Int => Unit
-    ~unrolledForeachImpl(unrollSize, '(seq), '(f))
+    ${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
+    val size = $seq.length
+    assert(size % (${unrollSize.toExpr}) == 0) // for simplicity of the implementation
     var i = 0
     while (i < size) {
       println("<log> start loop")
-      ~{
+      ${
         @tailrec def loop(j: Int, acc: Expr[Unit]): Expr[Unit] =
-          if (j >= 0) loop(j - 1, '{ ~f('((~seq)(i + ~j.toExpr))); ~acc })
+          if (j >= 0) loop(j - 1, '{ ${f('{$seq(i + ${j.toExpr})})}; $acc })
         else acc
-        loop(unrollSize - 1, '())
+        loop(unrollSize - 1, '{})
       }
-      i += ~unrollSize.toExpr
+      i += ${unrollSize.toExpr}
     }
   }
 }
diff --git a/tests/run/reflect-select-copy/assert_1.scala b/tests/run/reflect-select-copy/assert_1.scala
index 498bd48c4c2d..56ef7d642d47 100644
--- a/tests/run/reflect-select-copy/assert_1.scala
+++ b/tests/run/reflect-select-copy/assert_1.scala
@@ -3,7 +3,7 @@ import scala.tasty._
 
 object scalatest {
 
-  inline def assert(condition: => Boolean): Unit = ~assertImpl('(condition), '(""))
+  inline def assert(condition: => Boolean): Unit = ${ assertImpl('condition, '{""}) }
 
   def assertImpl(cond: Expr[Boolean], clue: Expr[Any])(implicit refl: Reflection): Expr[Unit] = {
     import refl._
@@ -13,9 +13,9 @@ object scalatest {
       case Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
         val Term.IsSelect(select) = sel
         val cond = Term.Apply(Term.Select.copy(select)(lhs, ">"), rhs :: Nil).seal[Boolean]
-        '{ scala.Predef.assert(~cond) }
+        '{ scala.Predef.assert($cond) }
       case _ =>
-        '{ scala.Predef.assert(~cond) }
+        '{ scala.Predef.assert($cond) }
     }
   }
 }
\ No newline at end of file
diff --git a/tests/run/t6111.scala b/tests/run/t6111.scala
index 915c23b446fe..2fa6c55a109b 100644
--- a/tests/run/t6111.scala
+++ b/tests/run/t6111.scala
@@ -23,6 +23,6 @@ object Test extends dotty.runtime.LegacyApp {
     case Foo(p) => p // p should be a pair of Int
   })
 
-  // Prints '(x, x)'
+  // Prints '{x, x}'
   "x" match { case Foo997(a) => println(a) }
 }
diff --git a/tests/run/t6888.scala b/tests/run/t6888.scala
index f58116c31c59..af69c6063d29 100644
--- a/tests/run/t6888.scala
+++ b/tests/run/t6888.scala
@@ -1,6 +1,6 @@
 class C {
   val x = 1
-  object $ {
+  object `$` {
     val y = x + x
     class abc$ {
       def xy = x + y
@@ -13,7 +13,7 @@ class C {
 
 object Test extends dotty.runtime.LegacyApp {
   val c = new C()
-  println(c.$.y)
-  println(c.$.abc$.xy)
-  println(new c.$.abc$().xy)
+  println(c.`$`.y)
+  println(c.`$`.abc$.xy)
+  println(new c.`$`.abc$().xy)
 }
diff --git a/tests/run/tasty-argument-tree-1/quoted_1.scala b/tests/run/tasty-argument-tree-1/quoted_1.scala
index 496332724bb2..987da2ce9fd0 100644
--- a/tests/run/tasty-argument-tree-1/quoted_1.scala
+++ b/tests/run/tasty-argument-tree-1/quoted_1.scala
@@ -3,15 +3,15 @@ import scala.tasty._
 
 object Macros {
 
-  inline def inspect[T](x: T): Unit = ~impl('(x))
+  inline def inspect[T](x: T): Unit = ${ impl('x) }
 
   def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
     val tree = x.unseal
     '{
       println()
-      println("tree: " + ~tree.show.toExpr)
-      println("tree deref. vals: " + ~tree.underlying.show.toExpr)
+      println("tree: " + ${tree.show.toExpr})
+      println("tree deref. vals: " + ${tree.underlying.show.toExpr})
     }
   }
 }
diff --git a/tests/run/tasty-custom-show/quoted_1.scala b/tests/run/tasty-custom-show/quoted_1.scala
index 96c51a43dd80..0011dbc9f5bd 100644
--- a/tests/run/tasty-custom-show/quoted_1.scala
+++ b/tests/run/tasty-custom-show/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty.Reflection
 object Macros {
 
   implicit inline def printOwners[T](x: => T): Unit =
-    ~impl('(x))
+    ${ impl('x) }
 
   def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -35,7 +35,7 @@ object Macros {
 
     val tree = x.unseal
     output.traverseTree(tree)
-    '(print(~buff.result().toExpr))
+    '{print(${buff.result().toExpr})}
   }
 
   def dummyShow(implicit reflect: Reflection): reflect.Printer = {
diff --git a/tests/run/tasty-definitions-1/quoted_1.scala b/tests/run/tasty-definitions-1/quoted_1.scala
index 6382461d5b3e..f9d565e16d3c 100644
--- a/tests/run/tasty-definitions-1/quoted_1.scala
+++ b/tests/run/tasty-definitions-1/quoted_1.scala
@@ -4,7 +4,7 @@ import scala.tasty._
 
 object Macros {
 
-  inline def testDefinitions(): Unit = ~testDefinitionsImpl
+  inline def testDefinitions(): Unit = ${testDefinitionsImpl}
 
   def testDefinitionsImpl(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -93,7 +93,7 @@ object Macros {
     printout(definitions.StringType.show)
 
 
-    '(println(~buff.result().mkString("\n").toExpr))
+    '{println(${buff.result().mkString("\n").toExpr})}
   }
 
 }
diff --git a/tests/run/tasty-eval/quoted_1.scala b/tests/run/tasty-eval/quoted_1.scala
index b06f2bc82c94..e423ec4fdadd 100644
--- a/tests/run/tasty-eval/quoted_1.scala
+++ b/tests/run/tasty-eval/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Macros {
 
   implicit inline def foo(i: Int): String =
-    ~impl('(i))
+    ${ impl('i) }
 
   def impl(i: Expr[Int])(implicit reflect: Reflection): Expr[String] = {
     value(i).toString.toExpr
diff --git a/tests/run/tasty-extractors-1/quoted_1.scala b/tests/run/tasty-extractors-1/quoted_1.scala
index ad349107df4a..68282ba2840e 100644
--- a/tests/run/tasty-extractors-1/quoted_1.scala
+++ b/tests/run/tasty-extractors-1/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Macros {
 
   implicit inline def printTree[T](x: => T): Unit =
-    ~impl('(x))
+    ${ impl('x) }
 
   def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -15,8 +15,8 @@ object Macros {
     val treeTpeStr = tree.tpe.show
 
     '{
-      println(~treeStr.toExpr)
-      println(~treeTpeStr.toExpr)
+      println(${treeStr.toExpr})
+      println(${treeTpeStr.toExpr})
       println()
     }
   }
diff --git a/tests/run/tasty-extractors-2/quoted_1.scala b/tests/run/tasty-extractors-2/quoted_1.scala
index 0d82d75da91f..e42a9e991260 100644
--- a/tests/run/tasty-extractors-2/quoted_1.scala
+++ b/tests/run/tasty-extractors-2/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Macros {
 
   implicit inline def printTree[T](x: => T): Unit =
-    ~impl('(x))
+    ${ impl('x) }
 
   def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -16,8 +16,8 @@ object Macros {
     val treeTpeStr = tree.tpe.show
 
     '{
-      println(~treeStr.toExpr)
-      println(~treeTpeStr.toExpr)
+      println(${treeStr.toExpr})
+      println(${treeTpeStr.toExpr})
       println()
     }
   }
diff --git a/tests/run/tasty-extractors-3/quoted_1.scala b/tests/run/tasty-extractors-3/quoted_1.scala
index 921a389db5e8..4762d885627d 100644
--- a/tests/run/tasty-extractors-3/quoted_1.scala
+++ b/tests/run/tasty-extractors-3/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty.Reflection
 object Macros {
 
   implicit inline def printTypes[T](x: => T): Unit =
-    ~impl('(x))
+    ${impl('x)}
 
   def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -21,6 +21,6 @@ object Macros {
 
     val tree = x.unseal
     traverser.traverseTree(tree)
-    '(print(~buff.result().toExpr))
+    '{print(${buff.result().toExpr})}
   }
 }
diff --git a/tests/run/tasty-extractors-constants-1/quoted_1.scala b/tests/run/tasty-extractors-constants-1/quoted_1.scala
index d9b6f1ead5f7..1b298081e3cb 100644
--- a/tests/run/tasty-extractors-constants-1/quoted_1.scala
+++ b/tests/run/tasty-extractors-constants-1/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty.util._
 
 object Macros {
 
-  implicit inline def testMacro: Unit = ~impl
+  implicit inline def testMacro: Unit = ${impl}
 
   def impl(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -16,12 +16,12 @@ object Macros {
     val Constant = new ConstantExtractor(reflect)
 
     3.toExpr match { case Constant(n) => stagedPrintln(n) }
-    '(4) match { case Constant(n) => stagedPrintln(n) }
-    '("abc") match { case Constant(n) => stagedPrintln(n) }
-    '(null) match { case Constant(n) => stagedPrintln(n) }
+    '{4} match { case Constant(n) => stagedPrintln(n) }
+    '{"abc"} match { case Constant(n) => stagedPrintln(n) }
+    '{null} match { case Constant(n) => stagedPrintln(n) }
 
-    '(new Object) match { case Constant(n) => println(n); case _ => stagedPrintln("OK") }
+    '{new Object} match { case Constant(n) => println(n); case _ => stagedPrintln("OK") }
 
-    '(print(~buff.result().toExpr))
+    '{print(${buff.result().toExpr})}
   }
 }
diff --git a/tests/run/tasty-extractors-types/quoted_1.scala b/tests/run/tasty-extractors-types/quoted_1.scala
index fb683ab4f81b..ca4526fab7dd 100644
--- a/tests/run/tasty-extractors-types/quoted_1.scala
+++ b/tests/run/tasty-extractors-types/quoted_1.scala
@@ -4,15 +4,15 @@ import scala.tasty._
 
 object Macros {
 
-  implicit inline def printType[T]: Unit = ~impl('[T])
+  implicit inline def printType[T]: Unit = ${ impl('[T]) }
 
   def impl[T](x: Type[T])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
 
     val tree = x.unseal
     '{
-      println(~tree.show.toExpr)
-      println(~tree.tpe.show.toExpr)
+      println(${tree.show.toExpr})
+      println(${tree.tpe.show.toExpr})
       println()
     }
   }
diff --git a/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala b/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala
index ae0fef057ab6..e00418e88077 100644
--- a/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala
+++ b/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala
@@ -7,7 +7,7 @@ object SourceFiles {
   def tastyContext(implicit ctx: Reflection): Reflection = ctx
 
   implicit inline def getThisFile: String =
-    ~getThisFileImpl
+    ${getThisFileImpl}
 
   def getThisFileImpl: Macro[String] = {
     val reflect = tastyContext
diff --git a/tests/run/tasty-getfile/Macro_1.scala b/tests/run/tasty-getfile/Macro_1.scala
index 8a4e0dca1c1b..dfe7b50e0f3a 100644
--- a/tests/run/tasty-getfile/Macro_1.scala
+++ b/tests/run/tasty-getfile/Macro_1.scala
@@ -4,7 +4,7 @@ import scala.tasty.Reflection
 object SourceFiles {
 
   implicit inline def getThisFile: String =
-    ~getThisFileImpl
+    ${getThisFileImpl}
 
   private def getThisFileImpl(implicit reflect: Reflection): Expr[String] = {
     import reflect._
diff --git a/tests/run/tasty-implicit-fun-context-2/Macro_1.scala b/tests/run/tasty-implicit-fun-context-2/Macro_1.scala
index 07c838ee6503..9d1713005148 100644
--- a/tests/run/tasty-implicit-fun-context-2/Macro_1.scala
+++ b/tests/run/tasty-implicit-fun-context-2/Macro_1.scala
@@ -7,10 +7,10 @@ object Foo {
   type Tastier[X] = given Reflection => X
 
   implicit inline def foo: String =
-    ~fooImpl
+    ${fooImpl}
 
   def fooImpl(implicit reflect: Reflection): given Reflection => Tastier[given Reflection => Macro[String]] = {
-    '("abc")
+    '{"abc"}
   }
 
 }
diff --git a/tests/run/tasty-indexed-map/quoted_1.scala b/tests/run/tasty-indexed-map/quoted_1.scala
index e6e31700910c..e84e95eb3372 100644
--- a/tests/run/tasty-indexed-map/quoted_1.scala
+++ b/tests/run/tasty-indexed-map/quoted_1.scala
@@ -24,7 +24,7 @@ object Index {
 
   implicit def zero[K, T]: Index[K, (K, T)] = new Index(0)
 
-  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ~succImpl[K, H, T]
+  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ${succImpl[K, H, T]}
 
   def succImpl[K, H, T](implicit reflect: Reflection, k: Type[K], h: Type[H], t: Type[T]): Expr[Index[K, (H, T)]] = {
     import reflect._
@@ -43,6 +43,6 @@ object Index {
 
     val index = keys.indexOf(key)
 
-    '(new Index(~index.toExpr))
+    '{new Index(${index.toExpr})}
   }
 }
diff --git a/tests/run/tasty-interpolation-1/Macro.scala b/tests/run/tasty-interpolation-1/Macro.scala
index 2846a1030642..106ddac78a52 100644
--- a/tests/run/tasty-interpolation-1/Macro.scala
+++ b/tests/run/tasty-interpolation-1/Macro.scala
@@ -8,26 +8,26 @@ import scala.quoted.Toolbox.Default._
 object Macro {
 
   class StringContextOps(strCtx: => StringContext) {
-    inline def s2(args: Any*): String = ~SIntepolator('(strCtx), '(args))
-    inline def raw2(args: Any*): String = ~RawIntepolator('(strCtx), '(args))
-    inline def foo(args: Any*): String = ~FooIntepolator('(strCtx), '(args))
+    inline def s2(args: Any*): String = ${SIntepolator('strCtx, 'args)}
+    inline def raw2(args: Any*): String = ${RawIntepolator('strCtx, 'args)}
+    inline def foo(args: Any*): String = ${FooIntepolator('strCtx, 'args)}
   }
   implicit inline def SCOps(strCtx: => StringContext): StringContextOps = new StringContextOps(strCtx)
 }
 
 object SIntepolator extends MacroStringInterpolator[String] {
   protected def interpolate(strCtx: StringContext, args: List[Expr[Any]])(implicit reflect: Reflection): Expr[String] =
-    '((~strCtx.toExpr).s(~args.toExprOfList: _*))
+    '{(${strCtx.toExpr}).s(${args.toExprOfList}: _*)}
 }
 
 object RawIntepolator extends MacroStringInterpolator[String] {
   protected def interpolate(strCtx: StringContext, args: List[Expr[Any]])(implicit reflect: Reflection): Expr[String] =
-    '((~strCtx.toExpr).raw(~args.toExprOfList: _*))
+    '{(${strCtx.toExpr}).raw(${args.toExprOfList}: _*)}
 }
 
 object FooIntepolator extends MacroStringInterpolator[String] {
   protected def interpolate(strCtx: StringContext, args: List[Expr[Any]])(implicit reflect: Reflection): Expr[String] =
-    '((~strCtx.toExpr).s(~args.map(_ => '("foo")).toExprOfList: _*))
+    '{(${strCtx.toExpr}).s(${args.map(_ => '{"foo"}).toExprOfList}: _*)}
 }
 
 // TODO put this class in the stdlib or separate project?
@@ -80,11 +80,11 @@ abstract class MacroStringInterpolator[T] {
       // TODO define in stdlib?
       implicit def ListIsLiftable: Liftable[List[String]] = new Liftable[List[String]] {
         override def toExpr(list: List[String]): Expr[List[String]] = list match {
-          case x :: xs => '(~x.toExpr :: ~toExpr(xs))
-          case Nil => '(Nil)
+          case x :: xs => '{${x.toExpr} :: ${toExpr(xs)}}
+          case Nil => '{Nil}
         }
       }
-      '(StringContext(~strCtx.parts.toList.toExpr: _*))
+      '{StringContext(${strCtx.parts.toList.toExpr}: _*)}
     }
   }
 
diff --git a/tests/run/tasty-linenumber-2/quoted_1.scala b/tests/run/tasty-linenumber-2/quoted_1.scala
index 164a326e9040..fd7e303da349 100644
--- a/tests/run/tasty-linenumber-2/quoted_1.scala
+++ b/tests/run/tasty-linenumber-2/quoted_1.scala
@@ -8,11 +8,11 @@ class LineNumber(val value: Int) {
 
 object LineNumber {
 
-  implicit inline def line: LineNumber = ~lineImpl
+  implicit inline def line: LineNumber = ${lineImpl}
 
   def lineImpl(implicit reflect: Reflection): Expr[LineNumber] = {
     import reflect._
-    '(new LineNumber(~rootPosition.startLine.toExpr))
+    '{new LineNumber(${rootPosition.startLine.toExpr})}
   }
 
 }
diff --git a/tests/run/tasty-linenumber/quoted_1.scala b/tests/run/tasty-linenumber/quoted_1.scala
index 1e4df5b9637b..49c64f59e1e4 100644
--- a/tests/run/tasty-linenumber/quoted_1.scala
+++ b/tests/run/tasty-linenumber/quoted_1.scala
@@ -9,11 +9,11 @@ class LineNumber(val value: Int) {
 object LineNumber {
 
   implicit inline def line[T >: Unit <: Unit]: LineNumber =
-    ~lineImpl('[T])
+    ${lineImpl('[T])}
 
   def lineImpl(x: Type[Unit])(implicit reflect: Reflection): Expr[LineNumber] = {
     import reflect._
-    '(new LineNumber(~rootPosition.startLine.toExpr))
+    '{new LineNumber(${rootPosition.startLine.toExpr})}
   }
 
 }
diff --git a/tests/run/tasty-location/quoted_1.scala b/tests/run/tasty-location/quoted_1.scala
index ddcf0e5a5e96..24755e59123b 100644
--- a/tests/run/tasty-location/quoted_1.scala
+++ b/tests/run/tasty-location/quoted_1.scala
@@ -6,7 +6,7 @@ case class Location(owners: List[String])
 
 object Location {
 
-  implicit inline def location: Location = ~impl
+  implicit inline def location: Location = ${impl}
 
   def impl(implicit reflect: Reflection): Expr[Location] = {
     import reflect._
@@ -16,11 +16,11 @@ object Location {
       else listOwnerNames(sym.owner, sym.name :: acc)
 
     val list = listOwnerNames(rootContext.owner, Nil)
-    '(new Location(~list.toExpr))
+    '{new Location(${list.toExpr})}
   }
 
   private implicit def ListIsLiftable[T : Liftable : Type]: Liftable[List[T]] = {
-    case x :: xs  => '{ ~x.toExpr :: ~xs.toExpr }
+    case x :: xs  => '{ ${x.toExpr} :: ${xs.toExpr} }
     case Nil => '{ List.empty[T] }
   }
 }
diff --git a/tests/run/tasty-macro-assert/quoted_1.scala b/tests/run/tasty-macro-assert/quoted_1.scala
index ae804284fa9e..feac01ef6173 100644
--- a/tests/run/tasty-macro-assert/quoted_1.scala
+++ b/tests/run/tasty-macro-assert/quoted_1.scala
@@ -12,7 +12,7 @@ object Asserts {
   object Ops
 
   inline def macroAssert(cond: => Boolean): Unit =
-    ~impl('(cond))
+    ${impl('cond)}
 
   def impl(cond: Expr[Boolean])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
@@ -35,11 +35,11 @@ object Asserts {
     tree match {
       case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
         op match {
-          case "===" => '(assertEquals(~left.seal[Any], ~right.seal[Any]))
-          case "!==" => '(assertNotEquals(~left.seal[Any], ~right.seal[Any]))
+          case "===" => '{assertEquals(${left.seal[Any]}, ${right.seal[Any]})}
+          case "!==" => '{assertNotEquals(${left.seal[Any]}, ${right.seal[Any]})}
         }
       case _ =>
-        '(assertTrue(~cond))
+        '{assertTrue($cond)}
     }
 
   }
diff --git a/tests/run/tasty-macro-const/quoted_1.scala b/tests/run/tasty-macro-const/quoted_1.scala
index 9d4a5dc970c3..f48da1280d5f 100644
--- a/tests/run/tasty-macro-const/quoted_1.scala
+++ b/tests/run/tasty-macro-const/quoted_1.scala
@@ -3,7 +3,7 @@ import scala.tasty._
 
 object Macros {
 
-  inline def natConst(x: Int): Int = ~natConstImpl('(x))
+  inline def natConst(x: Int): Int = ${ natConstImpl('x) }
 
   def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
     import reflection._
diff --git a/tests/run/tasty-original-source/Macros_1.scala b/tests/run/tasty-original-source/Macros_1.scala
index 44ce6448bbe7..2e04ab6c4091 100644
--- a/tests/run/tasty-original-source/Macros_1.scala
+++ b/tests/run/tasty-original-source/Macros_1.scala
@@ -3,12 +3,12 @@ import scala.tasty._
 
 object Macros {
 
-  implicit inline def withSource(arg: Any): (String, Any) = ~impl('(arg))
+  implicit inline def withSource(arg: Any): (String, Any) = ${ impl('arg) }
 
   private def impl(arg: Expr[Any])(implicit reflect: Reflection): Expr[(String, Any)] = {
     import reflect._
     val source = arg.unseal.underlyingArgument.pos.sourceCode.toString.toExpr
-    '(Tuple2(~source, ~arg))
+    '{Tuple2($source, $arg)}
   }
 
 }
diff --git a/tests/run/tasty-positioned/quoted_1.scala b/tests/run/tasty-positioned/quoted_1.scala
index 070453104e45..c1c82a7b5231 100644
--- a/tests/run/tasty-positioned/quoted_1.scala
+++ b/tests/run/tasty-positioned/quoted_1.scala
@@ -9,7 +9,7 @@ case class Positioned[T](value: T, position: Position)
 
 object Positioned {
 
-  implicit inline def apply[T](x: => T): Positioned[T] = ~impl('(x))
+  implicit inline def apply[T](x: => T): Positioned[T] = ${impl('x)}
 
   def impl[T](x: Expr[T])(implicit ev: Type[T], reflect: Reflection): Expr[Positioned[T]] = {
     import reflect.{Position => _, _}
@@ -23,7 +23,7 @@ object Positioned {
     val startColumn = pos.startColumn.toExpr
     val endColumn = pos.endColumn.toExpr
 
-    val liftedPosition = '(new Position(~path, ~start, ~end, ~startLine, ~startColumn, ~endLine, ~endColumn))
-    '(Positioned[T](~x, ~liftedPosition))
+    val liftedPosition = '{new Position($path, $start, $end, $startLine, $startColumn, $endLine, $endColumn)}
+    '{Positioned[T]($x, $liftedPosition)}
   }
 }
diff --git a/tests/run/tasty-seal-method/quoted_1.scala b/tests/run/tasty-seal-method/quoted_1.scala
index 09ecf2b9e936..41cff0a6ccee 100644
--- a/tests/run/tasty-seal-method/quoted_1.scala
+++ b/tests/run/tasty-seal-method/quoted_1.scala
@@ -5,7 +5,7 @@ import scala.tasty._
 object Asserts {
 
   inline def zeroLastArgs(x: => Int): Int =
-    ~zeroLastArgsImpl('(x))
+    ${ zeroLastArgsImpl('x) }
 
   /** Replaces last argument list by 0s */
   def zeroLastArgsImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[Int] = {
@@ -17,9 +17,9 @@ object Asserts {
           case Type.IsMethodType(_) =>
             args.size match {
               case 0 => fn.seal[() => Int].apply()
-              case 1 => fn.seal[Int => Int].apply('(0))
-              case 2 => fn.seal[(Int, Int) => Int].apply('(0), '(0))
-              case 3 => fn.seal[(Int, Int, Int) => Int].apply('(0), '(0), '(0))
+              case 1 => fn.seal[Int => Int].apply('{0})
+              case 2 => fn.seal[(Int, Int) => Int].apply('{0}, '{0})
+              case 3 => fn.seal[(Int, Int, Int) => Int].apply('{0}, '{0}, '{0})
             }
         }
       case _ => x
@@ -27,7 +27,7 @@ object Asserts {
   }
 
   inline def zeroAllArgs(x: => Int): Int =
-    ~zeroAllArgsImpl('(x))
+    ${ zeroAllArgsImpl('x) }
 
   /** Replaces all argument list by 0s */
   def zeroAllArgsImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[Int] = {
@@ -38,9 +38,9 @@ object Asserts {
         val pre = rec(fn)
         args.size match {
           case 0 => pre.seal[() => Any].apply().unseal
-          case 1 => pre.seal[Int => Any].apply('(0)).unseal
-          case 2 => pre.seal[(Int, Int) => Any].apply('(0), '(0)).unseal
-          case 3 => pre.seal[(Int, Int, Int) => Any].apply('(0), '(0), '(0)).unseal
+          case 1 => pre.seal[Int => Any].apply('{0}).unseal
+          case 2 => pre.seal[(Int, Int) => Any].apply('{0}, '{0}).unseal
+          case 3 => pre.seal[(Int, Int, Int) => Any].apply('{0}, '{0}, '{0}).unseal
         }
       case _ => term
     }
diff --git a/tests/run/tasty-subtyping/quoted_1.scala b/tests/run/tasty-subtyping/quoted_1.scala
index 3aecfd9505aa..c0b8831e2c2f 100644
--- a/tests/run/tasty-subtyping/quoted_1.scala
+++ b/tests/run/tasty-subtyping/quoted_1.scala
@@ -5,10 +5,10 @@ import scala.tasty._
 object Macros {
 
   inline def isTypeEqual[T, U]: Boolean =
-    ~isTypeEqualImpl('[T], '[U])
+    ${isTypeEqualImpl('[T], '[U])}
 
   inline def isSubTypeOf[T, U]: Boolean =
-    ~isSubTypeOfImpl('[T], '[U])
+    ${isSubTypeOfImpl('[T], '[U])}
 
   def isTypeEqualImpl[T, U](t: Type[T], u: Type[U])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
diff --git a/tests/run/tasty-tree-map/quoted_1.scala b/tests/run/tasty-tree-map/quoted_1.scala
index ceb98beb1343..af2e7c07a888 100644
--- a/tests/run/tasty-tree-map/quoted_1.scala
+++ b/tests/run/tasty-tree-map/quoted_1.scala
@@ -3,7 +3,7 @@ import scala.tasty._
 
 object Macros {
 
-  implicit inline def identityMaped[T](x: => T): T = ~impl('(x))
+  implicit inline def identityMaped[T](x: => T): T = ${ impl('x) }
 
   def impl[T: Type](x: Expr[T])(implicit reflection: Reflection): Expr[T] = {
     import reflection._
diff --git a/tests/run/tasty-typeof/Macro_1.scala b/tests/run/tasty-typeof/Macro_1.scala
index 90c716fd6982..3dcc4394b3c2 100644
--- a/tests/run/tasty-typeof/Macro_1.scala
+++ b/tests/run/tasty-typeof/Macro_1.scala
@@ -3,30 +3,30 @@ import scala.tasty._
 
 object Macros {
 
-  inline def testTypeOf(): Unit = ~testTypeOfImpl
+  inline def testTypeOf(): Unit = ${ testTypeOfImpl }
 
   private def testTypeOfImpl(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
     '{
-      assert(~(typeOf[Unit] =:= definitions.UnitType).toExpr, "Unit")
-      assert(~(typeOf[Byte] =:= definitions.ByteType).toExpr, "Byte")
-      assert(~(typeOf[Short] =:= definitions.ShortType).toExpr, "Short")
-      assert(~(typeOf[Int] =:= definitions.IntType).toExpr, "Int")
-      assert(~(typeOf[Long] =:= definitions.LongType).toExpr, "Long")
-      assert(~(typeOf[Float] =:= definitions.FloatType).toExpr, "Float")
-      assert(~(typeOf[Double] =:= definitions.DoubleType).toExpr, "Double")
-      assert(~(typeOf[Char] =:= definitions.CharType).toExpr, "Char")
-      assert(~(typeOf[String] =:= definitions.StringType).toExpr, "String")
+      assert(${(typeOf[Unit] =:= definitions.UnitType).toExpr}, "Unit")
+      assert(${(typeOf[Byte] =:= definitions.ByteType).toExpr}, "Byte")
+      assert(${(typeOf[Short] =:= definitions.ShortType).toExpr}, "Short")
+      assert(${(typeOf[Int] =:= definitions.IntType).toExpr}, "Int")
+      assert(${(typeOf[Long] =:= definitions.LongType).toExpr}, "Long")
+      assert(${(typeOf[Float] =:= definitions.FloatType).toExpr}, "Float")
+      assert(${(typeOf[Double] =:= definitions.DoubleType).toExpr}, "Double")
+      assert(${(typeOf[Char] =:= definitions.CharType).toExpr}, "Char")
+      assert(${(typeOf[String] =:= definitions.StringType).toExpr}, "String")
 
-      assert(~(typeOf[Any] =:= definitions.AnyType).toExpr, "Any")
-      assert(~(typeOf[AnyRef] =:= definitions.AnyRefType).toExpr, "AnyRef")
-      assert(~(typeOf[AnyVal] =:= definitions.AnyValType).toExpr, "AnyVal")
-      assert(~(typeOf[Object] =:= definitions.ObjectType).toExpr, "Object")
-      assert(~(typeOf[Nothing] =:= definitions.NothingType).toExpr, "Nothing")
+      assert(${(typeOf[Any] =:= definitions.AnyType).toExpr}, "Any")
+      assert(${(typeOf[AnyRef] =:= definitions.AnyRefType).toExpr}, "AnyRef")
+      assert(${(typeOf[AnyVal] =:= definitions.AnyValType).toExpr}, "AnyVal")
+      assert(${(typeOf[Object] =:= definitions.ObjectType).toExpr}, "Object")
+      assert(${(typeOf[Nothing] =:= definitions.NothingType).toExpr}, "Nothing")
 
-      println(~(typeOf[List[Int]].showCode.toExpr))
-      println(~(typeOf[Macros].showCode.toExpr))
-      println(~(typeOf[Macros.type].showCode.toExpr))
+      println(${typeOf[List[Int]].showCode.toExpr})
+      println(${typeOf[Macros].showCode.toExpr})
+      println(${typeOf[Macros.type].showCode.toExpr})
     }
   }
 
diff --git a/tests/run/xml-interpolation-1/XmlQuote_1.scala b/tests/run/xml-interpolation-1/XmlQuote_1.scala
index 56c9a624ae20..6986ba42ef8b 100644
--- a/tests/run/xml-interpolation-1/XmlQuote_1.scala
+++ b/tests/run/xml-interpolation-1/XmlQuote_1.scala
@@ -8,7 +8,7 @@ case class Xml(parts: String, args: List[Any])
 object XmlQuote {
 
   implicit class SCOps(ctx: StringContext) {
-    inline def xml(args: => Any*): Xml = ~XmlQuote.impl('(this), '(args))
+    inline def xml(args: => Any*): Xml = ${XmlQuote.impl('this, 'args)}
   }
 
   def impl(receiver: Expr[SCOps], args: Expr[Seq[Any]])
@@ -29,8 +29,8 @@ object XmlQuote {
       case x :: xs  =>
         val head = x.seal[Any]
         val tail = liftListOfAny(xs)
-        '{ ~head :: ~tail }
-      case Nil => '(Nil)
+        '{ $head :: $tail }
+      case Nil => '{Nil}
     }
 
     def isStringConstant(tree: Term) = tree match {
@@ -59,6 +59,6 @@ object XmlQuote {
     val Typed(Repeated(args0, _), _) = args.unseal.underlyingArgument
 
     val string = parts.mkString("??")
-    '(new Xml(~string.toExpr, ~liftListOfAny(args0)))
+    '{new Xml(${string.toExpr}, ${liftListOfAny(args0)})}
   }
 }
diff --git a/tests/run/xml-interpolation-2/XmlQuote_1.scala b/tests/run/xml-interpolation-2/XmlQuote_1.scala
index c51f145f9642..2d5792a4831f 100644
--- a/tests/run/xml-interpolation-2/XmlQuote_1.scala
+++ b/tests/run/xml-interpolation-2/XmlQuote_1.scala
@@ -10,7 +10,7 @@ case class Xml(parts: String, args: List[Any])
 object XmlQuote {
 
   class SCOps(ctx: => StringContext) {
-    inline def xml(args: Any*): Xml = ~XmlQuote.impl('(this), '(args))
+    inline def xml(args: Any*): Xml = ${ XmlQuote.impl('this, 'args) }
   }
   implicit inline def SCOps(ctx: => StringContext): SCOps = new SCOps(ctx)
 
@@ -58,11 +58,11 @@ object XmlQuote {
       case Typed(Repeated(args0, _), _) => // statically known args, make list directly
         args0.map(_.seal[Any]).toExprOfList
       case _ =>
-        '((~args).toList)
+        '{$args.toList}
 
     }
 
     val string = parts.mkString("??")
-    '(new Xml(~string.toExpr, ~args2))
+    '{new Xml(${string.toExpr}, $args2)}
   }
 }
diff --git a/tests/run/xml-interpolation-3/XmlQuote_1.scala b/tests/run/xml-interpolation-3/XmlQuote_1.scala
index 34402cd470b7..eeee5419af37 100644
--- a/tests/run/xml-interpolation-3/XmlQuote_1.scala
+++ b/tests/run/xml-interpolation-3/XmlQuote_1.scala
@@ -9,11 +9,11 @@ object XmlQuote {
 
   implicit object SCOps {
     inline def (inline ctx: StringContext) xml (args: => Any*): Xml =
-      ~XmlQuote.impl(ctx, '(args))
+      ${XmlQuote.impl(ctx, 'args)}
   }
 
   def impl(receiver: StringContext, args: Expr[Seq[Any]]): Expr[Xml] = {
     val string = receiver.parts.mkString("??")
-    '(new Xml(~string.toExpr, (~args).toList))
+    '{new Xml(${string.toExpr}, $args.toList)}
   }
 }
diff --git a/tests/untried/neg/t997.scala b/tests/untried/neg/t997.scala
index 1198738f2495..63c396b89920 100644
--- a/tests/untried/neg/t997.scala
+++ b/tests/untried/neg/t997.scala
@@ -3,10 +3,10 @@ object Foo { def unapply(x : String)  = Some((x, x)) }
 
 object Test extends App {
 
-// Prints '(x, x)'. Should compile as per SI-6111.
+// Prints '{x, x}'. Should compile as per SI-6111.
 "x" match { case Foo(a) => Console.println(a) }
 
-// Prints '(x,x)' as expected.
+// Prints '{x,x}' as expected.
 "x" match { case Foo(a, b) => Console.println((a,b)) }
 
 // Gives confusing error 'not found: value c'.