Avoid accidental conversion from ${ x } to x.unary_~ and back

Author: nicolasstucki

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) }
+    else if (n % 2 == 0) '{ val y = $x * $x; ${powerCode(n / 2, '{y})} }
+    else '{ $x * ${powerCode(n - 1, x)} }
 
 }

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1319,9 +1319,9 @@ object desugar {
         else
           Apply(ref(defn.QuotedExpr_applyR), t)
       case Splice(expr) =>
-        Select(expr, nme.UNARY_~)
+        Select(expr, nme.splice)
       case TypSplice(expr) =>
-        Select(expr, tpnme.UNARY_~)
+        Select(expr, tpnme.splice)
       case InterpolatedString(id, segments) =>
         val strs = segments map {
           case ts: Thicket => ts.trees.head

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -812,10 +812,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
      *  The result can be the contents of a term or type quote, which
      *  will return a term or type tree respectively.
      */
-    def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {
-      case tree: GenericApply[Type] if tree.symbol.isQuote => Some(tree.args.head)
-      case _ => None
-    }
+    def unapply(tree: tpd.Apply)(implicit ctx: Context): Option[tpd.Tree] =
+      if (tree.symbol.isQuote) Some(tree.args.head) else None
   }
 
   /** Extractors for splices */

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -707,16 +707,16 @@ 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
 
   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

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -328,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 =>

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.

compiler/src/dotty/tools/dotc/transform/Staging.scala

@@ -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 _ =>

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
 }

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

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)