Systematic use and caching of mangled

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -544,8 +544,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def toTermName: Name = n.toTermName
     def dropModule: Name = n.stripModuleClassSuffix
 
-    def len: Int = n.toSimpleName.length
-    def offset: Int = n.toSimpleName.start
+    def len: Int = n.mangled.toSimpleName.length
+    def offset: Int = n.mangled.toSimpleName.start
     def isTermName: Boolean = n.isTermName
     def startsWith(s: String): Boolean = n.startsWith(s)
   }

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

@@ -157,7 +157,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }
 
   /** Is name a left-associative operator? */
-  def isLeftAssoc(operator: Name) = !operator.isEmpty && (operator.toSimpleName.last != ':')
+  def isLeftAssoc(operator: Name) = !operator.isEmpty && (operator.lastPart.last != ':')
 
   /** can this type be a type pattern? */
   def mayBeTypePat(tree: untpd.Tree): Boolean = unsplice(tree) match {

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

@@ -174,6 +174,23 @@ object NameKinds {
     private val FalseSuper = termName("$$super")
     private val FalseSuperLength = FalseSuper.length
 
+    /** Mangle all names in the expanded prefix.
+     *  We do this since we cannot reliably unmange names in the prefix, so
+     *  we leave the prefix in mangled form instead.
+     */
+    override def apply(prefix: TermName, name: SimpleTermName) = {
+      def mangleAll(prefix: TermName): TermName = prefix rewrite {
+        case ExpandPrefixName(prefix1, name1) =>
+          val prefix2 = mangleAll(prefix1)
+          val name2 = name1.mangled
+          if (prefix2 == prefix1 && name2 == name1) prefix
+          else ExpandPrefixName(prefix2, name2)
+        case prefix: SimpleTermName =>
+          prefix.mangled
+      }
+      super.apply(mangleAll(prefix), name)
+    }
+
     override def unmangle(name: SimpleTermName): TermName = {
       var i = name.lastIndexOfSlice(str.EXPAND_SEPARATOR)
       if (i < 0) name

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

@@ -66,7 +66,16 @@ object Names {
     def isSimple: Boolean
     def asSimpleName: SimpleTermName
     def toSimpleName: SimpleTermName
-    def mangled: Name
+
+    @sharable // because it's just a cache for performance
+    private[this] var myMangled: Name = null
+
+    def mangle: ThisName
+
+    def mangled: ThisName = {
+      if (myMangled == null) myMangled = mangle
+      myMangled.asInstanceOf[ThisName]
+    }
 
     def rewrite(f: PartialFunction[Name, Name]): ThisName
     def collect[T](f: PartialFunction[Name, T]): Option[T]
@@ -265,7 +274,9 @@ object Names {
     def isSimple = true
     def asSimpleName = this
     def toSimpleName = this
-    def mangled = this
+    final def mangle = this
+
+    final override def mangled: SimpleTermName = this.asSimpleName
 
     def rewrite(f: PartialFunction[Name, Name]): ThisName =
       if (f.isDefinedAt(this)) likeSpaced(f(this)) else this
@@ -310,7 +321,7 @@ object Names {
     def isSimple = toTermName.isSimple
     def asSimpleName = toTermName.asSimpleName
     def toSimpleName = toTermName.toSimpleName
-    def mangled = toTermName.toSimpleName.toTypeName
+    final def mangle = toTermName.mangle.toTypeName
 
     def rewrite(f: PartialFunction[Name, Name]): ThisName = toTermName.rewrite(f).toTypeName
     def collect[T](f: PartialFunction[Name, T]): Option[T] = toTermName.collect(f)
@@ -346,12 +357,8 @@ object Names {
     def isSimple = false
     def asSimpleName = throw new UnsupportedOperationException(s"$debugString is not a simple name")
 
-    private[this] var simpleName: SimpleTermName = null
-    def toSimpleName = {
-      if (simpleName == null) simpleName = termName(toString)
-      simpleName
-    }
-    def mangled = toSimpleName
+    def toSimpleName = termName(toString)
+    final def mangle = toSimpleName
 
     def rewrite(f: PartialFunction[Name, Name]): ThisName =
       if (f.isDefinedAt(this)) likeSpaced(f(this))

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

@@ -23,7 +23,8 @@ object StdNames {
     final val INITIALIZER_PREFIX       = "initial$"
     final val SHADOWED_PREFIX          = "(shadowed)"
     final val AVOID_CLASH_SUFFIX       = "$_avoid_name_clash_$"
-    final val MODULE_SUFFIX            = NameTransformer.MODULE_SUFFIX_STRING
+    final val MODULE_SUFFIX            = "$"
+    final val NAME_JOIN                = "$"
     final val DEFAULT_GETTER           = "$default$"
     final val LOCALDUMMY_PREFIX        = "<local "       // owner of local blocks
     final val ANON_CLASS               = "$anon"
@@ -128,8 +129,7 @@ object StdNames {
     val EXPAND_SEPARATOR: N           = str.EXPAND_SEPARATOR
     val IMPL_CLASS_SUFFIX: N          = "$class"
     val IMPORT: N                     = "<import>"
-    val MODULE_SUFFIX: N              = NameTransformer.MODULE_SUFFIX_STRING
-    val NAME_JOIN: N                  = NameTransformer.NAME_JOIN_STRING
+    val MODULE_SUFFIX: N              = str.MODULE_SUFFIX
     val OPS_PACKAGE: N                = "<special-ops>"
     val OVERLOADED: N                 = "<overloaded>"
     val PACKAGE: N                    = "package"
@@ -257,9 +257,10 @@ object StdNames {
     val REIFY_FREE_THIS_SUFFIX: N   = "$this"
     val REIFY_FREE_VALUE_SUFFIX: N  = "$value"
     val REIFY_SYMDEF_PREFIX: N      = "symdef$"
-    val MODULE_INSTANCE_FIELD: N    = NameTransformer.MODULE_INSTANCE_NAME  // "MODULE$"
+    val MODULE_INSTANCE_FIELD: N    = "MODULE$"
     val OUTER: N                    = "$outer"
     val REFINE_CLASS: N             = "<refinement>"
+    val REFINE_CLASS_ENCODED: N     = "$lessrefinement$greater"
     val ROOTPKG: N                  = "_root_"
     val SELECTOR_DUMMY: N           = "<unapply-selector>"
     val SELF: N                     = "$this"

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

@@ -92,7 +92,7 @@ class ClassfileParser(
     val nameIdx      = in.nextChar
     currentClassName = pool.getClassName(nameIdx)
 
-    if (currentIsTopLevel && currentClassName != classRoot.fullName.toSimpleName)
+    if (currentIsTopLevel && currentClassName != classRoot.fullName.mangled.toTermName)
       mismatchError(currentClassName)
 
     addEnclosingTParams()
@@ -649,7 +649,7 @@ class ClassfileParser(
    */
   private def enterOwnInnerClasses()(implicit ctx: Context): Unit = {
     def className(name: Name): Name = {
-      val name1 = name.toSimpleName
+      val name1 = name.mangled.toSimpleName
       name1.drop(name1.lastIndexOf('.') + 1)
     }
 

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

@@ -157,7 +157,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         withoutPos(super.toText(tp))
       case tp: SelectionProto =>
         return "?{ " ~ toText(tp.name) ~
-           (" " provided !tp.name.toSimpleName.decode.last.isLetterOrDigit) ~
+           (" " provided !tp.name.lastPart.last.isLetterOrDigit) ~
            ": " ~ toText(tp.memberProto) ~ " }"
       case tp: ViewProto =>
         return toText(tp.argType) ~ " ?=>? " ~ toText(tp.resultType)

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

@@ -8,7 +8,7 @@ import core.Contexts._
 import core.Types._
 import core.Flags._
 import core.Decorators._
-import core.StdNames.nme
+import core.StdNames.{str, nme}
 import core.Names._
 import core.NameOps._
 import core.Phases._
@@ -22,7 +22,7 @@ import collection.{ mutable, immutable }
 import collection.mutable.{ HashMap, HashSet, LinkedHashMap, LinkedHashSet, TreeSet }
 
 object LambdaLift {
-  private val NJ = NameTransformer.NAME_JOIN_STRING
+  private val NJ = str.NAME_JOIN
   private class NoPath extends Exception
 }