encode packages in tasty and signatures

Author: bishabosha

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

@@ -141,7 +141,7 @@ object NameOps {
      *  followed by `kind` and the name.
      */
     def expandedName(base: Symbol, kind: QualifiedNameKind = ExpandedName)(using Context): N =
-      likeSpacedN { base.fullNameSeparated(ExpandPrefixName, kind, name) }
+      likeSpacedN { base.fullNameSeparated(ExpandPrefixName, kind, name, doEncodeName = false, encodePackages = false) }
 
     /** Revert the expanded name. */
     def unexpandedName: N = likeSpacedN {

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

@@ -458,29 +458,38 @@ object SymDenotations {
      *  are separated by `separator` strings as indicated by the given name kind.
      *  Drops package objects. Represents each term in the owner chain by a simple `_$`.
      */
-    def fullNameSeparated(kind: QualifiedNameKind)(using Context): Name =
-      maybeOwner.fullNameSeparated(kind, kind, name)
+    def fullNameSeparated(kind: QualifiedNameKind, encodePackages: Boolean)(using Context): Name =
+      val doEncodeName = encodePackages && is(PackageClass) && !isEffectiveRoot
+      maybeOwner.fullNameSeparated(kind, kind, name, doEncodeName, encodePackages)
 
     /** The encoded full path name of this denotation (separated by `prefixKind`),
      *  followed by the separator implied by `kind` and the given `name`.
      *  Drops package objects. Represents each term in the owner chain by a simple `_$`.
      */
-    def fullNameSeparated(prefixKind: QualifiedNameKind, kind: QualifiedNameKind, name: Name)(using Context): Name =
-      if (symbol == NoSymbol || isEffectiveRoot || kind == FlatName && is(PackageClass))
-        name
+    def fullNameSeparated(
+        prefixKind: QualifiedNameKind,
+        kind: QualifiedNameKind,
+        name: Name,
+        doEncodeName: Boolean,
+        encodePackages: Boolean
+    )(using Context): Name =
+      if symbol == NoSymbol || isEffectiveRoot || kind == FlatName && is(PackageClass) then {
+        if doEncodeName then name.encode else name
+      }
       else {
         var filler = ""
         var encl = symbol
         while (!encl.isClass && !encl.isPackageObject) {
           encl = encl.owner
           filler += "_$"
         }
-        var prefix = encl.fullNameSeparated(prefixKind)
+        var prefix = encl.fullNameSeparated(prefixKind, encodePackages)
         if (kind.separator == "$")
           // duplicate scalac's behavior: don't write a double '$$' for module class members.
           prefix = prefix.exclude(ModuleClassName)
-        def qualify(n: SimpleName) =
-          val qn = kind(prefix.toTermName, if (filler.isEmpty) n else termName(filler + n))
+        def qualify(n0: SimpleName) =
+          val n1 = if (filler.isEmpty) n0 else termName(filler + n0)
+          val qn = kind(prefix.toTermName, if doEncodeName then n1.encode else n1)
           if kind == FlatName && !encl.is(JavaDefined) then qn.compactified else qn
         val fn = name replace {
           case name: SimpleName => qualify(name)
@@ -490,10 +499,12 @@ object SymDenotations {
       }
 
     /** The encoded flat name of this denotation, where joined names are separated by `separator` characters. */
-    def flatName(using Context): Name = fullNameSeparated(FlatName)
+    def flatName(using Context): Name = fullNameSeparated(FlatName, encodePackages = false)
 
     /** `fullName` where `.' is the separator character */
-    def fullName(using Context): Name = fullNameSeparated(QualifiedName)
+    def fullName(using Context): Name = fullNameSeparated(QualifiedName, encodePackages = false)
+
+    def tastyCompatibleFullName(using Context): Name = fullNameSeparated(QualifiedName, encodePackages = true)
 
     private var myTargetName: Name = null
 
@@ -1701,7 +1712,7 @@ object SymDenotations {
     // ----- caches -------------------------------------------------------
 
     private var myTypeParams: List[TypeSymbol] = null
-    private var fullNameCache: SimpleIdentityMap[QualifiedNameKind, Name] = SimpleIdentityMap.empty
+    private var fullNameCache: SimpleIdentityMap[(QualifiedNameKind, Boolean), Name] = SimpleIdentityMap.empty
 
     private var myMemberCache: EqHashMap[Name, PreDenotation] = null
     private var myMemberCachePeriod: Period = Nowhere
@@ -2252,19 +2263,22 @@ object SymDenotations {
       }
     }
 
-    override final def fullNameSeparated(kind: QualifiedNameKind)(using Context): Name = {
-      val cached = fullNameCache(kind)
+    override final def fullNameSeparated(kind: QualifiedNameKind, encodePackages: Boolean)(using Context): Name = {
+      val cached = fullNameCache((kind, encodePackages))
       if (cached != null) cached
       else {
-        val fn = super.fullNameSeparated(kind)
-        fullNameCache = fullNameCache.updated(kind, fn)
+        val fn = super.fullNameSeparated(kind, encodePackages)
+        fullNameCache = fullNameCache.updated((kind, encodePackages), fn)
         fn
       }
     }
 
     // to avoid overloading ambiguities
     override def fullName(using Context): Name = super.fullName
 
+    // to avoid overloading ambiguities
+    override def tastyCompatibleFullName(using Context): Name = super.tastyCompatibleFullName
+
     override def primaryConstructor(using Context): Symbol = {
       def constrNamed(cname: TermName) = info.decls.denotsNamed(cname).last.symbol
         // denotsNamed returns Symbols in reverse order of occurrence

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

@@ -804,10 +804,10 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
               // It's important to use the initial symbol to compute the full name
               // because the current symbol might have a different name or owner
               // and signatures are required to be stable before erasure.
-              cls.initial.fullName
+              cls.initial.tastyCompatibleFullName
             else
-              cls.fullName
-          fullName.asTypeName
+              cls.tastyCompatibleFullName
+          fullName.asTypeName // TODO encode packages
       case tp: AppliedType =>
         val sym = tp.tycon.typeSymbol
         sigName( // todo: what about repeatedParam?

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -191,7 +191,7 @@ class TreePickler(pickler: TastyPickler) {
       }
       if (sym.is(Flags.Package)) {
         writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg)
-        pickleName(sym.fullName)
+        pickleName(sym.tastyCompatibleFullName)
       }
       else if (tpe.prefix == NoPrefix) {
         writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)

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

@@ -508,7 +508,7 @@ object Splicer {
             // Take the flatten name of the class and the full package name
             val pack = tpe.classSymbol.topLevelClass.owner
             val packageName = if (pack == defn.EmptyPackageClass) "" else s"${pack.fullName}."
-            packageName + tpe.classSymbol.fullNameSeparated(FlatName).toString
+            packageName + tpe.classSymbol.fullNameSeparated(FlatName, encodePackages = false).toString
         }
 
         val sym = param.classSymbol