Redesign Names.

tasty-query/shared/src/main/scala/tastyquery/Symbols.scala

@@ -179,14 +179,21 @@ object Symbols {
         throw AssertionError(s"Cannot construct static owner prefix for non-static-owner symbol $this")
     end staticOwnerPrefix
 
-    private def nameWithPrefix(addPrefix: Symbol => Boolean): FullyQualifiedName =
-      if isPackage && (owner == null || name == nme.EmptyPackageName) then FullyQualifiedName.rootPackageName
-      else
-        val pre = owner
-        if pre != null && addPrefix(pre) then pre.nameWithPrefix(addPrefix).mapLastOption(_.toTermName).select(name)
-        else FullyQualifiedName(name :: Nil)
-
-    final def fullName: FullyQualifiedName = nameWithPrefix(_.isStatic)
+    /** A full name of this symbol for display purposes, such as debugging or error messages.
+      *
+      * `displayFullName` must not be used to identify symbols, as it is not unique.
+      */
+    final def displayFullName: String = this match
+      case sym: PackageSymbol =>
+        if sym.isRootPackage then "_root_"
+        else if sym.name == nme.EmptyPackageName then "<empty>"
+        else sym.fullName.toString()
+      case sym: TermOrTypeSymbol =>
+        val owner = sym.owner
+        if owner.name == nme.EmptyPackageName then name.toString()
+        else if owner.isStatic then owner.displayFullName + "." + name.toString()
+        else name.toString()
+    end displayFullName
 
     final def isType: Boolean = this.isInstanceOf[TypeSymbol]
     final def isTerm: Boolean = this.isInstanceOf[TermSymbol]
@@ -1689,6 +1696,12 @@ object Symbols {
     this.withFlags(EmptyFlagSet, None)
     this.setAnnotations(Nil)
 
+    private lazy val _fullName: FullyQualifiedName =
+      if owner == null || name == nme.EmptyPackageName then FullyQualifiedName.rootPackageName
+      else owner.fullName.select(name)
+
+    final def fullName: FullyQualifiedName = _fullName
+
     private[tastyquery] def getPackageDeclOrCreate(name: SimpleName): PackageSymbol =
       getPackageDecl(name).getOrElse {
         assert(name != nme.EmptyPackageName, s"Trying to create a subpackage $name of $this")

tasty-query/shared/src/main/scala/tastyquery/reader/classfiles/ClassfileReader.scala

@@ -25,7 +25,7 @@ private[classfiles] final class ClassfileReader private () {
   }
 
   private def rootName(classOwner: DeclaringSymbol, classRoot: ClassData): String =
-    s"${classOwner.fullName}.${classRoot.binaryName}"
+    s"${classOwner.displayFullName}.${classRoot.binaryName}"
 
   private def acceptMagicNumber(classOwner: DeclaringSymbol, classRoot: ClassData)(using DataStream): Unit = {
     val magic = data.readU4()

tasty-query/shared/src/main/scala/tastyquery/reader/classfiles/JavaSignatures.scala

@@ -287,7 +287,7 @@ private[classfiles] object JavaSignatures:
       referenceType(null)
 
     def cookFailure(tname: TypeName, reason: String): Nothing =
-      val path = if !isClass then s"${member.owner.fullName}#${member.name}" else member.fullName
+      val path = if !isClass then s"${member.owner.displayFullName}#${member.name}" else member.displayFullName
       throw ClassfileFormatException(
         s"could not resolve type parameter `$tname` in signature `$signature` of $path because $reason"
       )

tasty-query/shared/src/test/scala/tastyquery/ReadTreeSuite.scala

@@ -58,8 +58,8 @@ class ReadTreeSuite extends RestrictedUnpicklingSuite {
   private object SymbolWithName:
     def unapply(sym: Symbol): Some[sym.ThisNameType] = Some(sym.name)
 
-  private object SymbolWithFullName:
-    def unapplySeq(sym: Symbol): Option[List[Name]] = Some(sym.fullName.path)
+  private object PackageWithFullName:
+    def unapplySeq(sym: PackageSymbol): Option[List[Name]] = Some(sym.fullName.path)
 
   private object ScalaPackageRef:
     def unapply(tree: PackageRef): Boolean = tree.fullyQualifiedName.path == List(termName("scala"))
@@ -255,7 +255,7 @@ class ReadTreeSuite extends RestrictedUnpicklingSuite {
     val nestedPackages: StructureCheck = {
       case PackageDef(
             SymbolWithName(SimpleName("simple_trees")),
-            List(PackageDef(SymbolWithFullName(SimpleName("simple_trees"), SimpleName("nested")), _))
+            List(PackageDef(PackageWithFullName(SimpleName("simple_trees"), SimpleName("nested")), _))
           ) =>
     }
 
@@ -264,7 +264,7 @@ class ReadTreeSuite extends RestrictedUnpicklingSuite {
 
   testUnpickleTopLevel("qualified-nested-package", "simple_trees.nested.InQualifiedNestedPackage") { tree =>
     val packageCheck: StructureCheck = {
-      case PackageDef(SymbolWithFullName(SimpleName("simple_trees"), SimpleName("nested")), _) =>
+      case PackageDef(PackageWithFullName(SimpleName("simple_trees"), SimpleName("nested")), _) =>
     }
 
     assert(containsSubtree(packageCheck)(clue(tree)))

tasty-query/shared/src/test/scala/tastyquery/SymbolSuite.scala

@@ -101,6 +101,18 @@ class SymbolSuite extends RestrictedUnpicklingSuite {
     assertContainsExactly(ctx.findPackage("empty_class"), Set(tname"EmptyClass"))
   }
 
+  testWithContext("package-full-names", "simple_trees.nested.InNestedPackage") {
+    assert(clue(defn.RootPackage.fullName) == FullyQualifiedName.rootPackageName)
+    assert(clue(defn.EmptyPackage.fullName) == FullyQualifiedName.rootPackageName)
+    assert(clue(defn.scalaPackage.fullName) == FullyQualifiedName.scalaPackageName)
+
+    val simpleTreesPackage = ctx.findPackage("simple_trees")
+    assert(clue(simpleTreesPackage.fullName) == FullyQualifiedName(List(termName("simple_trees"))))
+
+    val nestedPackage = ctx.findPackage("simple_trees.nested")
+    assert(clue(nestedPackage.fullName) == FullyQualifiedName(List(termName("simple_trees"), termName("nested"))))
+  }
+
   testWithContext("basic-symbol-structure-nested", "simple_trees.nested.InNestedPackage") {
     ctx.findTopLevelClass("simple_trees.nested.InNestedPackage")
     // InNestedPackage is the only declaration in the simple_trees.nested package
@@ -145,15 +157,15 @@ class SymbolSuite extends RestrictedUnpicklingSuite {
 
     val InNestedPackageClass = ctx.findTopLevelClass("simple_trees.nested.InNestedPackage")
 
-    assert(InNestedPackageClass.fullName.toString == "simple_trees.nested.InNestedPackage")
+    assert(InNestedPackageClass.displayFullName == "simple_trees.nested.InNestedPackage")
 
     val simpleTreesPkg = ctx.findPackage("simple_trees")
 
-    assert(simpleTreesPkg.fullName.toString == "simple_trees")
+    assert(simpleTreesPkg.displayFullName == "simple_trees")
 
     val (simpleTreesNestedPkg: PackageSymbol) = simpleTreesPkg.getDecl(name"nested").get: @unchecked
 
-    assert(simpleTreesNestedPkg.fullName.toString == "simple_trees.nested")
+    assert(simpleTreesNestedPkg.displayFullName == "simple_trees.nested")
 
     assert(simpleTreesPkg.getDecl(name"nested") == Some(simpleTreesNestedPkg))
   }