Unicode escapes are ordinary escape sequences

Author: martijnhoekstra

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

@@ -199,7 +199,7 @@ object Comments {
           // SI-8210 - The warning would be false negative when this symbol is a setter
           if (ownComment.indexOf("@inheritdoc") != -1 && ! sym.isSetter)
             dottydoc.println(s"${sym.span}: the comment for ${sym} contains @inheritdoc, but no parent comment is available to inherit from.")
-          ownComment.replaceAllLiterally("@inheritdoc", "<invalid inheritdoc annotation>")
+          ownComment.replace("@inheritdoc", "<invalid inheritdoc annotation>")
         case Some(sc) =>
           if (ownComment == "") sc
           else expandInheritdoc(sc, merge(sc, ownComment, sym), sym)
@@ -296,7 +296,7 @@ object Comments {
           if (childSection.indexOf("@inheritdoc") == -1)
             childSection
           else
-            childSection.replaceAllLiterally("@inheritdoc", parentSection)
+            childSection.replace("@inheritdoc", parentSection)
 
         def getParentSection(section: (Int, Int)): String = {
 
@@ -392,7 +392,7 @@ object Comments {
 
       // We suppressed expanding \$ throughout the recursion, and now we
       // need to replace \$ with $ so it looks as intended.
-      expandInternal(initialStr, 0).replaceAllLiterally("""\$""", "$")
+      expandInternal(initialStr, 0).replace("""\$""", "$")
     }
 
     def defineVariables(sym: Symbol)(implicit ctx: Context): Unit = {

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

@@ -10,7 +10,7 @@ abstract class CharArrayReader { self =>
   protected def startFrom: Int = 0
 
   /** Switch whether unicode should be decoded */
-  protected def decodeUni: Boolean = true
+  protected def decodeUni: Boolean = false
 
   /** An error routine to call on bad unicode escapes \\uxxxx. */
   protected def error(msg: String, offset: Int): Unit

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

@@ -14,6 +14,8 @@ object JavaScanners {
 
   class JavaScanner(source: SourceFile, override val startFrom: Offset = 0)(implicit ctx: Context) extends ScannerCommon(source)(ctx) {
 
+    override def decodeUni: Boolean = false
+
     def toToken(name: SimpleName): Token = {
       val idx = name.start
       if (idx >= 0 && idx <= lastKeywordStart) kwArray(idx) else IDENTIFIER

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

@@ -1190,6 +1190,26 @@ object Scanners {
      *  and advance to next character.
      */
     protected def getLitChar(): Unit =
+      def invalidUnicodeEscape() = {
+        error("invalid character in unicode escape sequence", charOffset - 1)
+        putChar(ch)
+      }
+      def putUnicode(): Unit = {
+        while ch == 'u' || ch == 'U' do nextChar()
+        var i = 0
+        var cp = 0
+        while (i < 4) {
+          val shift = (3 - i) * 4
+          val d = digit2int(ch, 16)
+          if(d < 0) {
+            return invalidUnicodeEscape()
+          }
+          cp += (d << shift)
+          nextChar()
+          i += 1
+        }
+        putChar(cp.asInstanceOf[Char])
+      }
       if (ch == '\\') {
         nextChar()
         if ('0' <= ch && ch <= '7') {
@@ -1206,6 +1226,9 @@ object Scanners {
           }
           putChar(oct.toChar)
         }
+        else if (ch == 'u' || ch == 'U') {
+          putUnicode()
+        }
         else {
           ch match {
             case 'b'  => putChar('\b')

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -69,8 +69,8 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
       // myMsg might be composed of several d"..." invocations -> nested
       // nonsensical tags possible
       msg
-        .replaceAllLiterally(nonSensicalStartTag, "")
-        .replaceAllLiterally(nonSensicalEndTag, "")
+        .replace(nonSensicalStartTag, "")
+        .replace(nonSensicalEndTag, "")
     else msg
 
   /** The message with potential embedded <nonsensical> tags */

compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala

@@ -63,6 +63,20 @@ class StringInterpolatorOpt extends MiniPhase {
     }
   }
 
+  //Extract the position from InvalidUnicodeEscapeException
+  //which due to bincompat reasons is unaccessible.
+  //TODO: remove once there is less restrictive bincompat
+  private object InvalidEscapePosition {
+    def unapply(t: Throwable): Option[Int] = t match {
+      case iee: StringContext.InvalidEscapeException => Some(iee.index)
+      case il: IllegalArgumentException => il.getMessage() match {
+          case s"""invalid unicode escape at index $index of $_""" => index.toIntOption
+          case _ => None
+      }
+      case _ => None
+    }
+  }
+
   /**
     * Match trees that resemble s and raw string interpolations. In the case of the s
     * interpolator, escapes the string constants. Exposes the string constants as well as
@@ -74,14 +88,37 @@ class StringInterpolatorOpt extends MiniPhase {
         case SOrRawInterpolator(strs, elems) =>
           if (tree.symbol == defn.StringContext_raw) Some(strs, elems)
           else { // tree.symbol == defn.StringContextS
+            import dotty.tools.dotc.util.SourcePosition
+            var stringPosition: SourcePosition = null
+            var offset: Int = 0
             try {
-              val escapedStrs = strs.map { str =>
-                val escapedValue = StringContext.processEscapes(str.const.stringValue)
-                cpy.Literal(str)(Constant(escapedValue))
+              val escapedStrs = strs.zipWithIndex.map { case (str @ Literal(c), i) =>
+                //the first literal is mispositioned at the opening of the quote
+                //rather than at the start of the string itself.
+                //https://github.com/lampepfl/dotty/issues/8627
+                stringPosition = str.sourcePos
+                (c.value, i) match {
+                  case (s: String, 0) => {
+                    val givenSpan = stringPosition.span
+                    val movedSpan1 = givenSpan.shift(1)
+                    val movedSpan3 = givenSpan.shift(3)
+                    val s1 = stringPosition.source.content.slice(movedSpan1.start, movedSpan1.end)
+                    val s3 = stringPosition.source.content.slice(movedSpan3.start, movedSpan3.end)
+                    offset = if (s1.toList == s.toList) 1 else if (s3.toList == s.toList) 3 else 0
+                  }
+                  case _ => offset = 0
+                }
+                val escaped = StringContext.processEscapes(str.const.stringValue)
+                cpy.Literal(str)(Constant(escaped))
               }
               Some(escapedStrs, elems)
             } catch {
-              case _: StringContext.InvalidEscapeException => None
+              case t @ InvalidEscapePosition(p) => {
+                val loc = stringPosition.span.startPos.shift(p + offset)
+                val errorPosition = stringPosition.withSpan(loc)
+                ctx.error(t.getMessage() + "\n", errorPosition)
+                None
+              }
             }
           }
         case _ => None

compiler/src/dotty/tools/io/ClassPath.scala

@@ -109,7 +109,7 @@ object ClassPath {
     else if (pattern endsWith wildSuffix) lsDir(Directory(pattern dropRight 2))
     else if (pattern contains '*') {
       try {
-        val regexp = ("^" + pattern.replaceAllLiterally("""\*""", """.*""") + "$").r
+        val regexp = ("^" + pattern.replace("""\*""", """.*""") + "$").r
         lsDir(Directory(pattern).parent, regexp.findFirstIn(_).isDefined)
       }
       catch { case _: PatternSyntaxException => List(pattern) }

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTest.scala

@@ -181,7 +181,7 @@ trait DottyBytecodeTest {
       val msg     = new StringBuilder
       val success = ms1.lazyZip(ms2) forall { (m1, m2) =>
         val c1 = f(m1)
-        val c2 = f(m2).replaceAllLiterally(name2, name1)
+        val c2 = f(m2).replace(name2, name1)
         if (c1 == c2)
           msg append (s"[ok] $m1")
         else

compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala

@@ -61,7 +61,7 @@ class SemanticdbTests:
         .resolve("semanticdb")
         .resolve(relpath)
         .resolveSibling(filename + ".semanticdb")
-      val expectPath = source.resolveSibling(filename.replaceAllLiterally(".scala", ".expect.scala"))
+      val expectPath = source.resolveSibling(filename.replace(".scala", ".expect.scala"))
       val doc = Tools.loadTextDocument(source, relpath, semanticdbPath)
       Tools.metac(doc, rootSrc.relativize(source))(using metacSb)
       val obtained = trimTrailingWhitespace(SemanticdbTests.printTextDocument(doc))

project/Build.scala

@@ -81,8 +81,8 @@ object Build {
    *  scala-library.
    */
   def stdlibVersion(implicit mode: Mode): String = mode match {
-    case NonBootstrapped => "2.13.1"
-    case Bootstrapped => "2.13.1"
+    case NonBootstrapped => "2.13.2-bin-db6fa85"
+    case Bootstrapped => "2.13.2-bin-db6fa85"
   }
 
   val dottyOrganization = "ch.epfl.lamp"
@@ -149,6 +149,7 @@ object Build {
 
   // Settings shared by the build (scoped in ThisBuild). Used in build.sbt
   lazy val thisBuildSettings = Def.settings(
+    resolvers += "scala-nightlies" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
     organization := dottyOrganization,
     organizationName := "LAMP/EPFL",
     organizationHomepage := Some(url("http://lamp.epfl.ch")),