Refactor checks for illegal characters in JVM names

The only check we actually need is whether an encoded name is valid or
not, so get rid of the unusued isValidJVMChar and replace
isValidJVMMethodChar by isValidInEncodedName, the only difference in the
latter is that ':' is also prohibited which doesn't change anything for
Scala since we encode ':' to "$colon" anyway.

Author: smarter

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

@@ -18,7 +18,7 @@ import typer.ErrorReporting._
 import reporting.ThrowingReporter
 import ast.Trees._
 import ast.{tpd, untpd}
-import scala.tasty.util.Chars._
+import scala.tasty.util.Chars
 import collection.mutable
 import ProtoTypes._
 
@@ -42,9 +42,8 @@ class TreeChecker extends Phase with SymTransformer {
   private val seenClasses = collection.mutable.HashMap[String, Symbol]()
   private val seenModuleVals = collection.mutable.HashMap[String, Symbol]()
 
-  def isValidJVMName(name: Name): Boolean = name.toString.forall(isValidJVMChar)
-
-  def isValidJVMMethodName(name: Name): Boolean = name.toString.forall(isValidJVMMethodChar)
+  def isValidEncodedName(name: Name): Boolean =
+    name.toString.forall(Chars.isValidInEncodedName)
 
   val NoSuperClass: FlagSet = Trait | Package
 
@@ -142,7 +141,8 @@ class TreeChecker extends Phase with SymTransformer {
         val sym = tree.symbol
         tree match {
           case tree: untpd.DefTree =>
-            assert(isValidJVMName(sym.name.encode), s"${sym.name.debugString} name is invalid on jvm")
+            assert(isValidEncodedName(sym.name.encode),
+              s"${sym.name.debugString} encoded name contains invalid character(s)")
             everDefinedSyms.get(sym) match {
               case Some(t)  =>
                 if (t ne tree)
@@ -387,8 +387,9 @@ class TreeChecker extends Phase with SymTransformer {
     override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context): Tree =
       withDefinedSyms(ddef.tparams) {
         withDefinedSyms(ddef.vparamss.flatten) {
-          if (!sym.isClassConstructor && !(sym.name eq nme.STATIC_CONSTRUCTOR))
-            assert(isValidJVMMethodName(sym.name.encode), s"${sym.name.debugString} name is invalid on jvm")
+          assert((sym.name eq nme.CONSTRUCTOR) || (sym.name eq nme.STATIC_CONSTRUCTOR) ||
+            isValidEncodedName(sym.name.encode),
+            s"${sym.name.debugString} encoded name contains invalid character(s)")
 
           ddef.vparamss.foreach(_.foreach { vparam =>
             assert(vparam.symbol.is(Param),

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

@@ -42,16 +42,22 @@ object NameTransformer {
   enterOp('?', "$qmark")
   enterOp('@', "$at")
 
-  /** Expand characters that are illegal as JVM method names by `$u`, followed
-   *  by the character's unicode expansion.
+  private def isOp(c: Char) = c < op2code.length && op2code(c) != null
+
+  /** Expand illegal characters by `$u` followed by the character's unicode expansion.
+   *  Illegal characters are those which are not valid in encoded name and won't
+   *  be replaced by `encode`.
    */
   def avoidIllegalChars(name: SimpleName): SimpleName = {
+    def isLegal(c: Char): Boolean = Chars.isValidInEncodedName(c) || isOp(c)
+
     var i = name.length - 1
-    while (i >= 0 && Chars.isValidJVMMethodChar(name(i))) i -= 1
+    while (i >= 0 && isLegal(name(i))) i -= 1
+
     if (i >= 0)
       termName(
         name.toString.flatMap(ch =>
-          if (Chars.isValidJVMMethodChar(ch)) ch.toString else "$u%04X".format(ch.toInt)))
+          if (isLegal(ch)) ch.toString else "$u%04X".format(ch.toInt)))
     else name
   }
 

library/src/scala/tasty/util/Chars.scala

@@ -72,11 +72,14 @@ object Chars {
     chtp == JCharacter.MATH_SYMBOL.toInt || chtp == JCharacter.OTHER_SYMBOL.toInt
   }
 
-  def isValidJVMChar(c: Char): Boolean =
-    !(c == '.' || c == ';' || c =='[' || c == '/')
-
-  def isValidJVMMethodChar(c: Char): Boolean =
-    !(c == '.' || c == ';' || c =='[' || c == '/' || c == '<' || c == '>')
+  /** Can `c` appear in an encoded name ?
+   *  This is true for all characters, except those prohibited in JVM signatures
+   *  (https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.9.1).
+   */
+  def isValidInEncodedName(c: Char): Boolean = (c: @switch) match {
+    case '.' | ';' | '[' | '/' | '<' | '>' | ':' => false
+    case _ => true
+  }
 
   private final val otherLetters = Set[Char]('\u0024', '\u005F')  // '$' and '_'
   private final val letterGroups = {

tests/run/special-names.scala

@@ -0,0 +1,27 @@
+class `.`
+class `;`
+class `[`
+class `/`
+class `<`
+class `>`
+class `:`
+
+object Test {
+  def `.`(x: `.`) = x
+  def `;`(x: `;`) = x
+  def `[`(x: `[`) = x
+  def `/`(x: `/`) = x
+  def `<`(x: `<`) = x
+  def `>`(x: `>`) = x
+  def `:`(x: `:`) = x
+
+  def main(args: Array[String]): Unit = {
+    `.`(new `.`)
+    `;`(new `;`)
+    `[`(new `[`)
+    `/`(new `/`)
+    `<`(new `<`)
+    `>`(new `>`)
+    `:`(new `:`)
+  }
+}