Revert to the Scala 2 name encoding scheme

There were several issues with the scheme we used so far:
- It's different from Scala 2, meaning that some Scala 2 methods could
not be called from Dotty and vice-versa (see the added
sbt-dotty/sbt-test/scala2-compat/akka/i3100.scala test for an example)
- It can lead to invalid filenames on Windows (#7492)
- The handling of backticks is broken: adding or removing backticks
around a name changes how it's encoded.

To maintain Scala 2 compat we don't have a lot of choices here, we must
use the same scheme, so this commit aligns NameTransformer.scala with
https://github.com/scala/scala/blob/2.13.x/src/library/scala/reflect/NameTransformer.scala

Some examples:

Method name | Old encoding | New encoding
-----------------------------------------
a_+         |      a_$plus |      a_$plus
`a_+`       |          a_+ |      a_$plus
`+_a`       |          +_a |      $plus_a
a_/         |       a_$div |       a_$div
`a_/`       |     a_$u002F |       a_$div

If a Dotty method is called `def a_$plus` we won't misinterpret it as
`a_+` because the method name comes from the tasty tree which stores
unencoded names. On the other hand, names coming from Java / Scala 2 as
well as top-level classnames might be misinterpreted as encoded names if
they contain a user-written $, this is left unspecified.

Fixes #3100. Fixes #5936. Fixes #7492.

Author: smarter

compiler/src/dotty/tools/backend/sjs/JSEncoding.scala

@@ -229,10 +229,7 @@ object JSEncoding {
     fullyMangledString(sym.name)
   }
 
-  /** Work around https://github.com/lampepfl/dotty/issues/5936 by bridging
-   *  most (all?) of the gap in encoding so that Dotty.js artifacts are
-   *  compatible with the restrictions on valid IR identifier names.
-   */
+  /** Convert Dotty mangled names into valid IR identifier names. */
   private def fullyMangledString(name: Name): String = {
     val base = name.mangledString
     val len = base.length
@@ -245,10 +242,8 @@ object JSEncoding {
         val c = base.charAt(i)
         if (c == '_')
           result.append("$und")
-        else if (Character.isJavaIdentifierPart(c) || c == '.')
-          result.append(c)
         else
-          result.append("$u%04x".format(c.toInt))
+          result.append(c)
         i += 1
       }
       result.toString()
@@ -257,7 +252,7 @@ object JSEncoding {
     var i = 0
     while (i != len) {
       val c = base.charAt(i)
-      if (c == '_' || !Character.isJavaIdentifierPart(c))
+      if (c == '_')
         return encodeFurther()
       i += 1
     }

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -9,7 +9,6 @@ import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.{FrontEnd, Namer}
 import util.{Property, SourceFile, SourcePosition}
-import util.NameTransformer.avoidIllegalChars
 import collection.mutable.ListBuffer
 import reporting.diagnostic.messages._
 import reporting.trace
@@ -935,7 +934,7 @@ object desugar {
 
   /** Invent a name for an anonympus given of type or template `impl`. */
   def inventGivenName(impl: Tree)(implicit ctx: Context): SimpleName =
-    avoidIllegalChars(s"given_${inventName(impl)}".toTermName.asSimpleName)
+    s"given_${inventName(impl)}".toTermName.asSimpleName
 
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
@@ -1250,7 +1249,7 @@ object desugar {
     else {
       var fileName = ctx.source.file.name
       val sourceName = fileName.take(fileName.lastIndexOf('.'))
-      val groupName = avoidIllegalChars((sourceName ++ str.TOPLEVEL_SUFFIX).toTermName.asSimpleName)
+      val groupName = (sourceName ++ str.TOPLEVEL_SUFFIX).toTermName.asSimpleName
       val grouped = ModuleDef(groupName, Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats))
       cpy.PackageDef(pdef)(pdef.pid, topStats :+ grouped)
     }

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

@@ -147,8 +147,8 @@ object Names {
     /** Is this name empty? */
     def isEmpty: Boolean
 
-    /** Does (the first part of) this name start with `str`? */
-    def startsWith(str: String): Boolean = firstPart.startsWith(str)
+    /** Does (the first part of) this name starting at index `start` starts with `str`? */
+    def startsWith(str: String, start: Int = 0): Boolean = firstPart.startsWith(str, start)
 
     /** Does (the last part of) this name end with `str`? */
     def endsWith(str: String): Boolean = lastPart.endsWith(str)
@@ -362,9 +362,9 @@ object Names {
 
     override def isEmpty: Boolean = length == 0
 
-    override def startsWith(str: String): Boolean = {
+    override def startsWith(str: String, start: Int): Boolean = {
       var i = 0
-      while (i < str.length && i < length && apply(i) == str(i)) i += 1
+      while (i < str.length && start + i < length && apply(start + i) == str(i)) i += 1
       i == str.length
     }
 

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -686,7 +686,7 @@ class ClassfileParser(
     for (entry <- innerClasses.values) {
       // create a new class member for immediate inner classes
       if (entry.outerName == currentClassName) {
-        val file = ctx.platform.classPath.findClassFile(entry.externalName.mangledString) getOrElse {
+        val file = ctx.platform.classPath.findClassFile(entry.externalName.toString) getOrElse {
           throw new AssertionError(entry.externalName)
         }
         enterClassAndModule(entry, file, entry.jflags)

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

@@ -7,7 +7,6 @@ import core.StdNames._, core.Comments._
 import util.SourceFile
 import java.lang.Character.isDigit
 import scala.internal.Chars._
-import util.NameTransformer.avoidIllegalChars
 import util.Spans.Span
 import config.Config
 import config.Printers.lexical
@@ -929,7 +928,6 @@ object Scanners {
       if (ch == '`') {
         nextChar()
         finishNamed(BACKQUOTED_IDENT)
-        name = avoidIllegalChars(name)
         if (name.length == 0)
           error("empty quoted identifier")
         else if (name == nme.WILDCARD)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -77,7 +77,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   override def nameString(name: Name): String =
-    if (ctx.settings.YdebugNames.value) name.debugString else NameTransformer.decodeIllegalChars(name.toString)
+    if (ctx.settings.YdebugNames.value) name.debugString else name.toString
 
   override protected def simpleNameString(sym: Symbol): String =
     nameString(if (ctx.property(XprintMode).isEmpty) sym.initial.name else sym.name)

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

@@ -103,16 +103,10 @@ object GenericSignatures {
         jsig(finalType)
     }
 
-    // This will reject any name that has characters that cannot appear in
-    // names on the JVM. Interop with Java is not guaranteed for those, so we
-    // dont need to generate signatures for them.
-    def sanitizeName(name: Name): String = {
-      val nameString = name.mangledString
-      if (nameString.forall(c => c == '.' || Character.isJavaIdentifierPart(c)))
-        nameString
-      else
-        throw new UnknownSig
-    }
+    // This works as long as mangled names are always valid valid Java identifiers,
+    // if we change our name encoding, we'll have to `throw new UnknownSig` here for
+    // names which are not valid Java identifiers (see git history of this method).
+    def sanitizeName(name: Name): String = name.mangledString
 
     // Anything which could conceivably be a module (i.e. isn't known to be
     // a type parameter or similar) must go through here or the signature is

compiler/src/dotty/tools/dotc/util/NameTransformer.scala

@@ -13,13 +13,16 @@ import scala.annotation.internal.sharable
 object NameTransformer {
 
   private val nops = 128
+  private val ncodes = 26 * 26
 
-  @sharable private val op2code = new Array[String](nops)
-  @sharable private val str2op = new mutable.HashMap[String, Char]
+  private class OpCodes(val op: Char, val code: String, val next: OpCodes)
 
+  @sharable private val op2code = new Array[String](nops)
+  @sharable private val code2op = new Array[OpCodes](ncodes)
   private def enterOp(op: Char, code: String) = {
-    op2code(op) = code
-    str2op(code) = op
+    op2code(op.toInt) = code
+    val c = (code.charAt(1) - 'a') * 26 + code.charAt(2) - 'a'
+    code2op(c.toInt) = new OpCodes(op, code, code2op(c))
   }
 
   /* Note: decoding assumes opcodes are only ever lowercase. */
@@ -42,99 +45,102 @@ object NameTransformer {
   enterOp('?', "$qmark")
   enterOp('@', "$at")
 
-  /** Expand characters that are illegal as JVM method names by `$u`, followed
-   *  by the character's unicode expansion.
-   */
-  def avoidIllegalChars(name: SimpleName): SimpleName = {
-    var i = name.length - 1
-    while (i >= 0 && Chars.isValidJVMMethodChar(name(i))) i -= 1
-    if (i >= 0)
-      termName(
-        name.toString.flatMap(ch =>
-          if (Chars.isValidJVMMethodChar(ch)) ch.toString else "$u%04X".format(ch.toInt)))
-    else name
-  }
-
-  /** Decode expanded characters starting with `$u`, followed by the character's unicode expansion. */
-  def decodeIllegalChars(name: String): String =
-    if (name.contains("$u")) {
-      val sb = new mutable.StringBuilder()
-      var i = 0
-      while (i < name.length)
-        if (i < name.length - 5 && name(i) == '$' && name(i + 1) == 'u') {
-          val numbers = name.substring(i + 2, i + 6)
-          try sb.append(Integer.valueOf(name.substring(i + 2, i + 6), 16).toChar)
-          catch {
-            case _: java.lang.NumberFormatException =>
-              sb.append("$u").append(numbers)
-          }
-          i += 6
-        }
-        else {
-          sb.append(name(i))
-          i += 1
-        }
-      sb.result()
-    }
-    else name
-
-  /** Replace operator symbols by corresponding expansion strings.
-   *
-   *  @param name the string to encode
-   *  @return     the string with all recognized opchars replaced with their encoding
-   *
-   *  Operator symbols are only recognized if they make up the whole name, or
-   *  if they make up the last part of the name which follows a `_`.
+  /** Replace operator symbols by corresponding expansion strings, and replace
+   *  characters that are not valid Java identifiers by "$u" followed by the
+   *  character's unicode expansion.
    */
   def encode(name: SimpleName): SimpleName = {
-    def loop(len: Int, ops: List[String]): SimpleName = {
-      def convert =
-        if (ops.isEmpty) name
-        else {
-          val buf = new java.lang.StringBuilder
-          buf.append(chrs, name.start, len)
-          for (op <- ops) buf.append(op)
-          termName(buf.toString)
+    var buf: StringBuilder = null
+    val len = name.length
+    var i = 0
+    while (i < len) {
+      val c = name(i)
+      if (c < nops && (op2code(c.toInt) ne null)) {
+        if (buf eq null) {
+          buf = new StringBuilder()
+          buf.append(name.sliceToString(0, i))
+        }
+        buf.append(op2code(c.toInt))
+      /* Handle glyphs that are not valid Java/JVM identifiers */
+      }
+      else if (!Character.isJavaIdentifierPart(c)) {
+        if (buf eq null) {
+          buf = new StringBuilder()
+          buf.append(name.sliceToString(0, i))
         }
-      if (len == 0 || name(len - 1) == '_') convert
-      else {
-        val ch = name(len - 1)
-        if (ch <= nops && op2code(ch) != null)
-          loop(len - 1, op2code(ch) :: ops)
-        else if (Chars.isSpecial(ch))
-          loop(len - 1, ch.toString :: ops)
-        else name
+        buf.append("$u%04X".format(c.toInt))
       }
+      else if (buf ne null) {
+        buf.append(c)
+      }
+      i += 1
     }
-    loop(name.length, Nil)
+    if (buf eq null) name else termName(buf.toString)
   }
 
-  /** Replace operator expansions by the operators themselves.
-   *  Operator expansions are only recognized if they make up the whole name, or
-   *  if they make up the last part of the name which follows a `_`.
+  /** Replace operator expansions by the operators themselves,
+   *  and decode `$u....` expansions into unicode characters.
    */
   def decode(name: SimpleName): SimpleName = {
-    def loop(len: Int, ops: List[Char]): SimpleName = {
-      def convert =
-        if (ops.isEmpty) name
-        else {
-          val buf = new java.lang.StringBuilder
-          buf.append(chrs, name.start, len)
-          for (op <- ops) buf.append(op)
-          termName(buf.toString)
-        }
-      if (len == 0 || name(len - 1) == '_') convert
-      else if (Chars.isSpecial(name(len - 1))) loop(len - 1, name(len - 1) :: ops)
-      else {
-        val idx = name.lastIndexOf('$', len - 1)
-        if (idx >= 0 && idx + 2 < len)
-          str2op.get(name.sliceToString(idx, len)) match {
-            case Some(ch) => loop(idx, ch :: ops)
-            case None => name
+    //System.out.println("decode: " + name);//DEBUG
+    var buf: StringBuilder = null
+    val len = name.length
+    var i = 0
+    while (i < len) {
+      var ops: OpCodes = null
+      var unicode = false
+      val c = name(i)
+      if (c == '$' && i + 2 < len) {
+        val ch1 = name(i + 1)
+        if ('a' <= ch1 && ch1 <= 'z') {
+          val ch2 = name(i + 2)
+          if ('a' <= ch2 && ch2 <= 'z') {
+            ops = code2op((ch1 - 'a') * 26 + ch2 - 'a')
+            while ((ops ne null) && !name.startsWith(ops.code, i)) ops = ops.next
+            if (ops ne null) {
+              if (buf eq null) {
+                buf = new StringBuilder()
+                buf.append(name.sliceToString(0, i))
+              }
+              buf.append(ops.op)
+              i += ops.code.length()
+            }
+            /* Handle the decoding of Unicode glyphs that are
+             * not valid Java/JVM identifiers */
+          } else if ((len - i) >= 6 && // Check that there are enough characters left
+                     ch1 == 'u' &&
+                     ((Character.isDigit(ch2)) ||
+                     ('A' <= ch2 && ch2 <= 'F'))) {
+            /* Skip past "$u", next four should be hexadecimal */
+            val hex = name.sliceToString(i+2, i+6)
+            try {
+              val str = Integer.parseInt(hex, 16).toChar
+              if (buf eq null) {
+                buf = new StringBuilder()
+                buf.append(name.sliceToString(0, i))
+              }
+              buf.append(str)
+              /* 2 for "$u", 4 for hexadecimal number */
+              i += 6
+              unicode = true
+            } catch {
+              case _:NumberFormatException =>
+                /* `hex` did not decode to a hexadecimal number, so
+                 * do nothing. */
+            }
           }
-        else name
+        }
+      }
+      /* If we didn't see an opcode or encoded Unicode glyph, and the
+        buffer is non-empty, write the current character and advance
+         one */
+      if ((ops eq null) && !unicode) {
+        if (buf ne null)
+          buf.append(c)
+        i += 1
       }
     }
-    loop(name.length, Nil)
+    //System.out.println("= " + (if (buf == null) name else buf.toString()));//DEBUG
+    if (buf eq null) name else termName(buf.toString)
   }
 }

sbt-dotty/sbt-test/scala2-compat/akka/build.sbt

@@ -0,0 +1,8 @@
+scalaVersion := sys.props("plugin.scalaVersion")
+
+libraryDependencies ++= {
+  Seq(
+    ("com.typesafe.akka" %% "akka-http"   % "10.1.10"),
+    ("com.typesafe.akka" %% "akka-stream" % "2.6.0")
+  ).map(_.withDottyCompat(scalaVersion.value))
+}

sbt-dotty/sbt-test/scala2-compat/akka/i3100.scala

@@ -0,0 +1,12 @@
+import akka.actor.ActorSystem
+import akka.http.scaladsl.Http
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.server.Directives._
+import akka.stream.ActorMaterializer
+import scala.io.StdIn
+
+object WebServer {
+  def main(args: Array[String]): Unit = {
+    val x = ContentTypes.`text/html(UTF-8)`
+  }
+}

sbt-dotty/sbt-test/scala2-compat/akka/project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % sys.props("plugin.version"))

sbt-dotty/sbt-test/scala2-compat/akka/test

@@ -0,0 +1 @@
+> compile

tests/generic-java-signatures/invalidNames.check

@@ -0,0 +1 @@
+$bang$u005B$u005D$colon$u003B$bang$bang <: java.util.Date