Fix quote parsing

Correctly handle 'this, 'true, 'false, 'null.

Author: odersky

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
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -703,25 +703,50 @@ 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
+
+      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)
+          case FLOATLIT               => in.floatVal(isNegated).toFloat
+          case DOUBLELIT              => in.floatVal(isNegated)
+          case STRINGLIT | STRINGPART => in.strVal
+          case TRUE                   => true
+          case FALSE                  => false
+          case NULL                   => null
+          case _                      =>
+            syntaxErrorOrIncomplete(IllegalLiteral())
+            null
+        }
+        Literal(Constant(value))
       }
-      val isNegated = negOffset < in.offset
+
       atSpan(negOffset) {
         if (in.token == QUOTEID) {
-          if ((staged & StageKind.Spliced) != 0 && isIdentifierStart(in.name(1)))
-            Quote(atSpan(in.offset + 1)(Ident(in.name.drop(1))))
+          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.""")
+                                        |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), "\")")
@@ -730,20 +755,11 @@ object Parsers {
           }
         }
         else if (in.token == INTERPOLATIONID) interpolatedString(inPattern)
-        else finish(in.token match {
-          case CHARLIT                => in.charVal
-          case INTLIT                 => in.intVal(isNegated).toInt
-          case LONGLIT                => in.intVal(isNegated)
-          case FLOATLIT               => in.floatVal(isNegated).toFloat
-          case DOUBLELIT              => in.floatVal(isNegated)
-          case STRINGLIT | STRINGPART => in.strVal
-          case TRUE                   => true
-          case FALSE                  => false
-          case NULL                   => null
-          case _                      =>
-            syntaxErrorOrIncomplete(IllegalLiteral())
-            null
-        })
+        else {
+          val t = literalOf(in.token)
+          in.nextToken()
+          t
+        }
       }
     }
 

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
 

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._

library/src-bootstrapped/scala/StagedTuple.scala

@@ -253,7 +253,7 @@ object StagedTuple {
 
     def bind[T: Type](in: Expr[U] => Expr[T]): Expr[T] = '{
       val t: U = $expr
-      ${in('{t})}
+      ${in('t)}
     }
 
   }

library/src-bootstrapped/scala/Tuple.scala

@@ -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)
@@ -60,7 +60,7 @@ sealed trait Tuple extends Any {
     }
 
   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,7 +121,7 @@ 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 {
@@ -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]
@@ -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 {
@@ -430,8 +430,8 @@ 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]) }
+       'this, constValueOpt[Size[this.type]],
+       'n, constValueOpt[n.type]) }
 }
 
 object NonEmptyTuple {

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)
   }
 }

tests/disabled/run/i4803d/Macro_1.scala

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

tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala

@@ -9,7 +9,7 @@ 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] = {

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