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,23 @@ 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.map(str => {
+                stringPosition = str.sourcePos
+                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 errorSpan = stringPosition.span.startPos.shift(p)
+                val errorPosition = stringPosition.withSpan(errorSpan)
+                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/parsing/StringInterpolationPositionTest.scala

@@ -0,0 +1,43 @@
+package dotty.tools
+package dotc
+package parsing
+
+import ast.untpd._
+import org.junit.Test
+
+class StringInterpolationPositionTest extends ParserTest {
+
+  val tq = "\"\"\""
+  val program = s"""
+    |class A {
+    |  val expr = 42
+    |  val s0 = s"string1"
+    |  val s1 = s"string1$${expr}string2"
+    |  val s2 = s"string1$${expr}string2$${expr}string3"
+    |  val s0m = s${tq}string1${tq}
+    |  val s1m = s${tq}string1$${expr}string2${tq}
+    |  val s2m = s${tq}string1$${expr}string2$${expr}string3${tq}
+    |}""".stripMargin
+
+  @Test
+  def interpolationLiteralPosition: Unit = {
+    val t = parseText(program)
+    t match {
+      case PackageDef(_, List(TypeDef(_, Template(_, _, _, statements: List[Tree])))) => {
+        val interpolations = statements.collect{ case ValDef(_, _, InterpolatedString(_, int)) => int }
+        val lits = interpolations.flatten.flatMap {
+          case l @ Literal(_) => List(l)
+          case Thicket(trees) => trees.collect { case l @ Literal(_) => l }
+        }
+        for {
+          lit <- lits
+          Literal(c) = lit
+          str <- List(c.value).collect { case str: String => str}
+        } {
+          val fromPos = program.substring(lit.span.start, lit.span.end)
+          assert(fromPos == str, s"$fromPos == $str")
+        }
+      }
+    }
+  }
+}

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