Merge remote-tracking branch 'upstream/master' into dotty-t8124

Author: michelou

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

@@ -256,6 +256,13 @@ object Scanners {
       case _ => false
     }
 
+    /** Are we in a `${ }` block? such that RBRACE exits back into multiline string. */
+    private def inMultiLineInterpolatedExpression =
+      currentRegion match {
+        case InBraces(_, InString(true, _)) => true
+        case _ => false
+      }
+
     /** read next token and return last offset
      */
     def skipToken(): Offset = {
@@ -742,17 +749,22 @@ object Scanners {
             if (token == INTERPOLATIONID) {
               nextRawChar()
               if (ch == '\"') {
-                nextRawChar()
-                if (ch == '\"') {
+                if (lookaheadChar() == '\"') {
+                  nextRawChar()
+                  //offset += 3   // first part is positioned at the quote
                   nextRawChar()
                   stringPart(multiLine = true)
                 }
                 else {
+                  nextChar()
                   token = STRINGLIT
                   strVal = ""
                 }
               }
-              else stringPart(multiLine = false)
+              else {
+                //offset += 1   // first part is positioned at the quote
+                stringPart(multiLine = false)
+              }
             }
             else {
               nextChar()
@@ -806,7 +818,8 @@ object Scanners {
         case ')' =>
           nextChar(); token = RPAREN
         case '}' =>
-          nextChar(); token = RBRACE
+          if (inMultiLineInterpolatedExpression) nextRawChar() else nextChar()
+          token = RBRACE
         case '[' =>
           nextChar(); token = LBRACKET
         case ']' =>

compiler/test/dotty/tools/dotc/parsing/ParserEdgeTest.scala

@@ -0,0 +1,73 @@
+package dotty.tools
+package dotc
+package parsing
+
+import ast.untpd._
+import core.Constants._
+
+import org.junit.Test
+
+class ParserEdgeTest extends ParserTest {
+  //
+  // CR after right brace of interpolated expression was stripped.
+  //
+  @Test def `t9944 respect line separator`: Unit = {
+    // avoid git stripping CR from a test file; also, inlining doesn't demonstrate the behavior.
+    val CR = "\u000D"
+    val NL = "\u000A"
+    val triple = "\"" * 3
+    val text = s"""class C { def g = "X" ; def f = s${triple}123${CR}${NL}$${g}${CR}${NL}456${triple} }"""
+    def isStripped(s: String) = s.contains(NL) && !s.contains(CR)
+
+    // sanity check
+    assert(text.linesIterator.size == 3, s"line count ${text.linesIterator.size}")
+    assert(text.linesIterator.forall(!isStripped(_)))
+
+    val t = parseText(text)
+    //println(t.show)
+    assert(!t.existsSubTree {
+      case Literal(const @ Constant(_)) if const.tag == StringTag => isStripped(const.stringValue)
+      case st => false
+    })
+  }
+  /* was:
+  package <empty> {
+    class C {
+      def g = "X"
+      def f =
+        s"123\r\n{
+          {
+            g
+          }
+        }\n456"
+    }
+  }
+   * now:
+  package <empty> {
+    class C {
+      def g = "X"
+      def f =
+        s"123\r\n{
+          {
+            g
+          }
+        }\r\n456"
+    }
+  }
+   * tests/run/t9944 expressed ordinarily, with CR as indicated:
+class C {
+  def g = 42
+  def f =
+    s"""123^M
+       |${ g }^M
+       |123""".stripMargin
+}
+
+object Test extends App {
+  println(new C().f.getBytes.toList.map(c => f"$c%02x"))
+}
+   * was:
+➜ dotr Test
+List(31, 32, 33, 0d, 0a, 34, 32, 0a, 31, 32, 33)
+   */
+}

compiler/test/dotty/tools/dotc/parsing/ParserTest.scala

@@ -23,9 +23,10 @@ class ParserTest extends DottyTest {
     parsedTrees.clear()
   }
 
-  def parse(file: PlainFile): Tree = {
-    //println("***** parsing " + file)
-    val source = new SourceFile(file, Codec.UTF8)
+  def parse(file: PlainFile): Tree = parseSource(new SourceFile(file, Codec.UTF8))
+
+  private def parseSource(source: SourceFile): Tree = {
+    //println("***** parsing " + source.file)
     val parser = new Parser(source)
     val tree = parser.parse()
     parsed += 1
@@ -41,4 +42,6 @@ class ParserTest extends DottyTest {
     for (d <- dir.dirs)
       parseDir(d.path)
   }
+
+  def parseText(code: String): Tree = parseSource(SourceFile.virtual("<code>", code))
 }

library/src/scala/Eql.scala

@@ -23,15 +23,15 @@ object Eql {
   def eqlAny[L, R]: Eql[L, R] = derived
 
   // Instances of `Eql` for common Java types
-  implicit def eqlNumber   : Eql[Number, Number] = derived
-  implicit def eqlString   : Eql[String, String] = derived
+  given eqlNumber as Eql[Number, Number] = derived
+  given eqlString as Eql[String, String] = derived
 
   // The next three definitions can go into the companion objects of classes
   // Seq, Set, and Proxy. For now they are here in order not to have to touch the
   // source code of these classes
-  implicit def eqlSeq[T, U](implicit eq: Eql[T, U]): Eql[GenSeq[T], GenSeq[U]] = derived
-  implicit def eqlSet[T, U](implicit eq: Eql[T, U]): Eql[Set[T], Set[U]] = derived
+  given eqlSeq[T, U](using eq: Eql[T, U]) as Eql[GenSeq[T], GenSeq[U]] = derived
+  given eqlSet[T, U](using eq: Eql[T, U]) as Eql[Set[T], Set[U]] = derived
 
   // true asymmetry, modeling the (somewhat problematic) nature of equals on Proxies
-  implicit def eqlProxy    : Eql[Proxy, AnyRef]  = derived
+  given eqlProxy as Eql[Proxy, AnyRef]  = derived
 }

library/src/scala/implicits/Not.scala

@@ -7,8 +7,8 @@ package scala.implicits
  *  value of type `C` is available. If we do not want to prioritize `i1` and `i2` by
  *  putting them in different traits we can instead define the following:
  *
- *     implicit def i1: D(implicit ev: C) = ...
- *     implicit def i2: D(implicit ev: Not[C]) = ...
+ *     given i1: D(using ev: C) = ...
+ *     given i2: D(using ev: Not[C]) = ...
  *
  *  `Not` is treated specially in implicit search, similar to the way logical negation
  *  is treated in Prolog: The implicit search for `Not[C]` succeeds if and only if the implicit
@@ -27,7 +27,7 @@ final class Not[+T] private ()
 trait LowPriorityNot {
 
   /** A fallback method used to emulate negation in Scala 2 */
-  implicit def default[T]: Not[T] = Not.value
+  given default[T] as Not[T] = Not.value
 }
 object Not extends LowPriorityNot {
 
@@ -38,8 +38,8 @@ object Not extends LowPriorityNot {
   def value: Not[Nothing] = new Not[Nothing]()
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
-  implicit def amb1[T](implicit ev: T): Not[T] = ???
+  given amb1[T](using ev: T) as Not[T] = ???
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
-  implicit def amb2[T](implicit ev: T): Not[T] = ???
+  given amb2[T](using ev: T) as Not[T] = ???
 }

tests/pos/t7919.scala

@@ -0,0 +1,11 @@
+
+object X {
+  val x = s""
+  val y = true
+}
+
+/* was:
+4 |  val y = true
+  |  ^^^
+  |  end of statement expected but 'val' found
+*/