Require QuoteContext warning on quotes

Author: nicolasstucki

community-build/community-projects/scalatest

@@ -80,6 +80,8 @@ object Splicer {
   /** Tree interpreter that evaluates the tree */
   private class Interpreter(pos: SourcePosition, classLoader: ClassLoader)(implicit ctx: Context) extends AbstractInterpreter {
 
+    def checking: Boolean = false
+
     type Result = Object
 
     /** Returns the interpreted result of interpreting the code a call to the symbol with default arguments.
@@ -277,6 +279,7 @@ object Splicer {
 
   /** Tree interpreter that tests if tree can be interpreted */
   private class CheckValidMacroBody(implicit ctx: Context) extends AbstractInterpreter {
+    def checking: Boolean = true
 
     type Result = Unit
 
@@ -312,6 +315,9 @@ object Splicer {
 
   /** Abstract Tree interpreter that can interpret calls to static methods with quoted or inline arguments */
   private abstract class AbstractInterpreter(implicit ctx: Context) {
+
+    def checking: Boolean
+
     type Env = Map[Name, Result]
     type Result
 
@@ -370,20 +376,10 @@ object Splicer {
 
       // Interpret `foo(j = x, i = y)` which it is expanded to
       // `val j$1 = x; val i$1 = y; foo(i = y, j = x)`
-      case Block(stats, expr) =>
-        var unexpected: Option[Result] = None
-        val newEnv = stats.foldLeft(env)((accEnv, stat) => stat match {
-          case stat: ValDef if stat.symbol.is(Synthetic) =>
-            accEnv.updated(stat.name, interpretTree(stat.rhs)(accEnv))
-          case stat =>
-            if (unexpected.isEmpty)
-              unexpected = Some(unexpectedTree(stat))
-            accEnv
-        })
-        unexpected.getOrElse(interpretTree(expr)(newEnv))
+      case Block(stats, expr) => interpretBlock(stats, expr)
       case NamedArg(_, arg) => interpretTree(arg)
 
-      case Inlined(_, Nil, expansion) => interpretTree(expansion)
+      case Inlined(_, bindings, expansion) => interpretBlock(bindings, expansion)
 
       case Typed(expr, _) =>
         interpretTree(expr)
@@ -395,6 +391,19 @@ object Splicer {
         unexpectedTree(tree)
     }
 
+    private def interpretBlock(stats: List[Tree], expr: Tree)(implicit env: Env) = {
+      var unexpected: Option[Result] = None
+      val newEnv = stats.foldLeft(env)((accEnv, stat) => stat match {
+        case stat: ValDef if stat.symbol.is(Synthetic) || !checking =>
+          accEnv.updated(stat.name, interpretTree(stat.rhs)(accEnv))
+        case stat =>
+          if (unexpected.isEmpty)
+            unexpected = Some(unexpectedTree(stat))
+          accEnv
+      })
+      unexpected.getOrElse(interpretTree(expr)(newEnv))
+    }
+
     object Call {
       def unapply(arg: Tree): Option[(RefTree, List[Tree])] = arg match {
         case Select(Call(fn, args), nme.apply) if defn.isImplicitFunctionType(fn.tpe.widenDealias.finalResultType) =>

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

@@ -1962,15 +1962,18 @@ class Typer extends Namer
       case untpd.TypSplice(innerType) if tree.isType =>
         ctx.warning("Canceled splice directly inside a quote. '[ ${ XYZ } ] is equivalent to XYZ.", tree.sourcePos)
         typed(innerType, pt)
-      case quoted if quoted.isType =>
-        ctx.compilationUnit.needsStaging = true
-        typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuoteR), quoted :: Nil), pt)(quoteContext).withSpan(tree.span)
       case quoted =>
         ctx.compilationUnit.needsStaging = true
-        if (ctx.mode.is(Mode.Pattern) && level == 0)
-          typedQuotePattern(quoted, pt, tree.span)
-        else
-          typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuoteR), quoted), pt)(quoteContext).withSpan(tree.span)
+
+        val qctx = inferImplicitArg(defn.QuoteContextType, tree.span)
+        if (level == 0 && qctx.tpe.isInstanceOf[SearchFailureType])
+          ctx.error(missingArgMsg(qctx, defn.QuoteContextType, ""), ctx.source.atSpan(tree.span))
+
+        val tree1 =
+          if (quoted.isType) typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuoteR), quoted :: Nil), pt)(quoteContext)
+          else if (ctx.mode.is(Mode.Pattern) && level == 0) typedQuotePattern(quoted, pt, qctx)
+          else typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuoteR), quoted), pt)(quoteContext)
+        tree1.withSpan(tree.span)
     }
   }
 
@@ -2019,7 +2022,7 @@ class Typer extends Namer
    *        ) => ...
    *  ```
    */
-  private def typedQuotePattern(quoted: untpd.Tree, pt: Type, quoteSpan: Span)(implicit ctx: Context): Tree = {
+  private def typedQuotePattern(quoted: untpd.Tree, pt: Type, qctx: tpd.Tree)(implicit ctx: Context): Tree = {
     val exprPt = pt.baseType(defn.QuotedExprClass)
     val quotedPt = if (exprPt.exists) exprPt.argTypesHi.head else defn.AnyType
     val quoted1 = typedExpr(quoted, quotedPt)(quoteContext.addMode(Mode.QuotedPattern))
@@ -2068,7 +2071,7 @@ class Typer extends Namer
       implicits =
         ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
           Literal(Constant(typeBindings.nonEmpty)) ::
-          implicitArgTree(defn.QuoteContextType, quoteSpan) :: Nil,
+          qctx :: Nil,
       patterns = splicePat :: Nil,
       proto = pt)
   }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1,7 +1,8 @@
+scala> import scala.quoted._
 scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
 def toolbox: quoted.Toolbox
-scala> val v = '{ (if true then Some(1) else None).map(v => v+1) }
-val v: quoted.Expr[Option[Int]] = Expr(<pickled tasty>)
+scala> def v given QuoteContext = '{ (if true then Some(1) else None).map(v => v+1) }
+def v given (x$1: quoted.QuoteContext): quoted.Expr[Option[Int]]
 scala> scala.quoted.withQuoteContext(v.show)
 val res0: String = (if (true) scala.Some.apply[scala.Int](1) else scala.None).map[scala.Int](((v: scala.Int) => v.+(1)))
 scala> scala.quoted.run(v)

compiler/test-resources/repl/i4539 renamed to compiler/test-resources/pending/repl/i4539

@@ -1,8 +1,8 @@
 scala> import scala.quoted._
-
-scala> def assertImpl(expr: Expr[Boolean]) = '{ if !($expr) then throw new AssertionError("failed assertion")}
-def assertImpl(expr: quoted.Expr[Boolean]): quoted.Expr[Unit]
-
+scala> def assertImpl(expr: Expr[Boolean]) given (qctx: QuoteContext) = '{ if !($expr) then throw new AssertionError("failed assertion")}
+def assertImpl
+  (expr: quoted.Expr[Boolean])
+     given (qctx: quoted.QuoteContext): quoted.Expr[Unit]
 scala>   inline def assert(expr: => Boolean): Unit =  ${ assertImpl('{expr}) }
 def assert(expr: => Boolean): Unit
 

compiler/test-resources/repl-macros/i6007

@@ -10,6 +10,7 @@ trait TreeUtils {
 
   /** Bind the `rhs` to a `val` and use it in `body` */
   def let(rhs: Term)(body: Ident => Term): Term = {
+    delegate for QuoteContext = new QuoteContext(reflect)
     type T // TODO probably it is better to use the Sealed contruct rather than let the user create their own existential type
     implicit val rhsTpe: quoted.Type[T] = rhs.tpe.seal.asInstanceOf[quoted.Type[T]]
     val rhsExpr = rhs.seal.cast[T]

compiler/test-resources/repl/i5551

@@ -54,7 +54,7 @@ package object quoted {
   implicit object ExprOps {
     def (x: T) toExpr[T: Liftable] given QuoteContext: Expr[T] = the[Liftable[T]].toExpr(x)
 
-    def (list: List[Expr[T]]) toExprOfList[T] given Type[T]: Expr[List[T]] = list match {
+    def (list: List[Expr[T]]) toExprOfList[T: Type] given QuoteContext: Expr[List[T]] = list match {
       case x :: xs  => '{ $x :: ${xs.toExprOfList} }
       case Nil => '{ Nil }
     }

library/src-3.x/scala/tasty/reflect/utils/TreeUtils.scala

@@ -1,4 +1,6 @@
-class Test {
+import scala.quoted.QuoteContext
+
+def test given QuoteContext = {
   val x = '{0}
   val y = '{ // error: Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.
     $x

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

@@ -24,6 +24,6 @@ object Test {
     impl(1)
   }
 
-  def impl(i: Int): Expr[Unit] = '{}
+  def impl(i: Int) given QuoteContext: Expr[Unit] = '{}
 
 }