Replace quoted toExpr with Expr.apply

Author: nicolasstucki

docs/docs/reference/changed-features/numeric-literals.md

@@ -206,7 +206,7 @@ implementation method `fromDigitsImpl`. Here is its definition:
       case Const(ds) =>
         try {
           val BigFloat(m, e) = apply(ds)
-          '{BigFloat(${m.toExpr}, ${e.toExpr})}
+          '{BigFloat(${Expr(m)}, ${Expr(e)})}
         }
         catch {
           case ex: FromDigits.FromDigitsException =>

docs/docs/reference/metaprogramming/macros.md

@@ -228,7 +228,7 @@ import given scala.quoted._
 
 def compile(e: Exp, env: Map[String, Expr[Int]]): Expr[Int] = e match {
   case Num(n) =>
-    n.toExpr
+    Expr(n)
   case Plus(e1, e2) =>
     '{ ${ compile(e1, env) } + ${ compile(e2, env) } }
   case Var(x) =>
@@ -241,7 +241,7 @@ 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`
+The body of the first clause, `case Num(n) => Expr(n)`, looks suspicious. `n`
 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
@@ -308,7 +308,7 @@ Using lifting, we can now give the missing definition of `showExpr` in the intro
 ```scala
 def showExpr[T](expr: Expr[T]): Expr[String] = {
   val code: String = expr.show
-  code.toExpr
+  Expr(code)
 }
 ```
 That is, the `showExpr` method converts its `Expr` argument to a string (`code`), and lifts

docs/docs/reference/metaprogramming/tasty-reflect.md

@@ -68,7 +68,7 @@ The method `qctx.tasty.Term.seal[T]` provides a way to go back to a
 `quoted.Expr[Any]`. Note that the type is `Expr[Any]`. Consequently, the type
 must be set explicitly with a checked `cast` call. If the type does not conform
 to it an exception will be thrown. In the code above, we could have replaced
-`n.toExpr` by `xTree.seal.cast[Int]`.
+`Expr(n)` by `xTree.seal.cast[Int]`.
 
 ### Obtaining the underlying argument
 

library/src-bootstrapped/dotty/internal/StringContextMacro.scala

@@ -751,6 +751,6 @@ object StringContextMacro {
     }
 
     // macro expansion
-    '{(${parts.mkString.toExpr}).format(${argsExpr}: _*)}
+    '{(${Expr(parts.mkString)}).format(${argsExpr}: _*)}
   }
 }

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -3,6 +3,7 @@ package scala
 package object quoted {
 
   implicit object ExprOps {
-    def (x: T) toExpr[T: Liftable](given QuoteContext): Expr[T] = summon[Liftable[T]].toExpr(x)
+    @deprecated("Use scala.quoted.Expr.apply instead", "0.19.0")
+    def (x: T) toExpr[T: Liftable](given QuoteContext): Expr[T] = Expr(x)
   }
 }

library/src-bootstrapped/scala/quoted/package.scala

@@ -65,6 +65,9 @@ package quoted {
       Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[Expr[T]]
     }
 
+    /** Lift a value into an expression containing the construction of that value */
+    def apply[T: Liftable](x: T)(given QuoteContext): Expr[T] = summon[Liftable[T]].toExpr(x)
+
     /** Lifts this sequence of expressions into an expression of a sequence
      *
      *  Transforms a sequence of expression

library/src/scala/quoted/Expr.scala

@@ -3,5 +3,5 @@ package scala.quoted
 /** Enable implicit conversion from a term of type `T` to an expression of type `Expr[T]` */
 object autolift {
   /** Implicit conversion from a term of type `T` to an expression of type `Expr[T]` */
-  given autoToExpr[T](given Liftable[T], QuoteContext): Conversion[T, Expr[T]] = _.toExpr
+  given autoToExpr[T](given Liftable[T], QuoteContext): Conversion[T, Expr[T]] = Expr(_)
 }

library/src/scala/quoted/autolift.scala

@@ -5,6 +5,6 @@ object Macro {
 
   inline def charOrString(inline str: String) <: Char | String = ${ impl(str) }
 
-  def impl(str: String) = if (str.length == 1) str.charAt(0).toExpr else str.toExpr
+  def impl(str: String) = if (str.length == 1) Expr(str.charAt(0)) else Expr(str)
 
 }

tests/disabled/pos/quote-whitebox/Macro_1.scala

@@ -20,7 +20,7 @@ object Even {
             ctx.error(ex.getMessage)
             Even(0)
         }
-      '{Even(${ev.n.toExpr})}
+      '{Even(${Expr(ev.n)})}
     case _ =>
       '{evenFromDigits($digits)}
   }