Merge the functionality of Descriptors into JavaSignatures.

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

@@ -215,8 +215,8 @@ private[reader] object ClassfileParser {
       allRegisteredSymbols += sym
       sym
 
-    def loadMembers(): IArray[(TermSymbol, AccessFlags, SigOrDesc)] =
-      val buf = IArray.newBuilder[(TermSymbol, AccessFlags, SigOrDesc)]
+    def loadMembers(): IArray[(TermSymbol, AccessFlags, MemberSig)] =
+      val buf = IArray.newBuilder[(TermSymbol, AccessFlags, MemberSig)]
       structure.fields.use {
         reader.readFields { (name, sigOrDesc, access) =>
           buf += ((createMember(name, EmptyFlagSet, access), access, sigOrDesc))
@@ -242,7 +242,7 @@ private[reader] object ClassfileParser {
           structure.supers.use {
             val superClass = reader.readSuperClass().map(binaryName)
             val interfaces = reader.readInterfaces().map(binaryName)
-            Descriptors.parseSupers(cls, superClass, interfaces)
+            JavaSignatures.parseSupers(cls, superClass, interfaces)
           }
       end parents
       val parents1 =
@@ -262,10 +262,8 @@ private[reader] object ClassfileParser {
       else if cls.isString then rctx.createStringMagicMethods(cls)
       else if cls.isJavaEnum then rctx.createEnumMagicMethods(cls)
 
-    for (sym, javaFlags, sigOrDesc) <- loadMembers() do
-      val parsedType = sigOrDesc match
-        case SigOrDesc.Desc(desc) => Descriptors.parseDescriptor(sym, desc)
-        case SigOrDesc.Sig(sig)   => JavaSignatures.parseSignature(sym, sig, allRegisteredSymbols)
+    for (sym, javaFlags, memberSig) <- loadMembers() do
+      val parsedType = JavaSignatures.parseSignature(sym, memberSig, allRegisteredSymbols)
       val adaptedType =
         if sym.isMethod && sym.name == nme.Constructor then cls.makePolyConstructorType(parsedType)
         else if sym.isMethod && javaFlags.isVarargsIfMethod then patchForVarargs(sym, parsedType)

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

@@ -187,15 +187,15 @@ private[classfiles] final class ClassfileReader private () {
     reader
   }
 
-  def readFields(op: (SimpleName, SigOrDesc, AccessFlags) => Unit)(using DataStream, ConstantPool): Unit =
+  def readFields(op: (SimpleName, MemberSig, AccessFlags) => Unit)(using DataStream, ConstantPool): Unit =
     readMembers(isMethod = false, op)
 
-  def readMethods(op: (SimpleName, SigOrDesc, AccessFlags) => Unit)(using DataStream, ConstantPool): Unit =
+  def readMethods(op: (SimpleName, MemberSig, AccessFlags) => Unit)(using DataStream, ConstantPool): Unit =
     readMembers(isMethod = true, op)
 
   private def readMembers(
     isMethod: Boolean,
-    op: (SimpleName, SigOrDesc, AccessFlags) => Unit
+    op: (SimpleName, MemberSig, AccessFlags) => Unit
   )(using ds: DataStream, pool: ConstantPool): Unit = {
     val count = data.readU2()
     loop(count) {
@@ -214,9 +214,7 @@ private[classfiles] final class ClassfileReader private () {
         case _ => false
       }
       val sig = sigOrNull
-      if !accessFlags.isSynthetic then
-        if sig == null then op(name, SigOrDesc.Desc(desc), accessFlags)
-        else op(name, SigOrDesc.Sig(sig), accessFlags)
+      if !accessFlags.isSynthetic then op(name, if sig == null then desc else sig, accessFlags)
     }
   }
 
@@ -399,9 +397,7 @@ private[classfiles] object ClassfileReader {
     IArray.unsafeFromArray(arr)
   }
 
-  enum SigOrDesc:
-    case Sig(str: String)
-    case Desc(str: String)
+  type MemberSig = String
 
   enum SigOrSupers:
     case Sig(str: String)

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

@@ -15,14 +15,29 @@ import tastyquery.Symbols.*
 import tastyquery.reader.ReaderContext
 import tastyquery.reader.ReaderContext.rctx
 
-import ClassfileParser.{InnerClasses, Resolver}
+import ClassfileParser.{InnerClasses, Resolver, resolver}
 
 private[classfiles] object JavaSignatures:
 
   private object IgnoreTParamRefs
 
   private type JavaSignature = Null | PolyType | Map[TypeName, ClassTypeParamSymbol] | IgnoreTParamRefs.type
 
+  private def classRef(binaryName: SimpleName)(using ReaderContext, InnerClasses, Resolver): TypeRef =
+    resolver.resolve(binaryName)
+
+  def parseSupers(cls: ClassSymbol, superClass: Option[SimpleName], interfaces: IArray[SimpleName])(
+    using ReaderContext,
+    InnerClasses,
+    Resolver
+  ): List[Type] =
+    cls.withTypeParams(Nil)
+    if cls.isObject then rctx.AnyType :: rctx.MatchableType :: Nil
+    else
+      val superRef = superClass.map(classRef).getOrElse(rctx.ObjectType)
+      superRef :: interfaces.map(classRef).toList
+  end parseSupers
+
   @throws[ClassfileFormatException]
   def parseSignature(member: Symbol { val owner: Symbol }, signature: String, allRegisteredSymbols: Growable[Symbol])(
     using ReaderContext,
@@ -163,7 +178,7 @@ private[classfiles] object JavaSignatures:
       end classTypeSignatureRest
 
       if consume('L') then // must have 'L', identifier, and ';'.
-        val pre = simpleClassTypeSignature(Descriptors.classRef(binaryName()))
+        val pre = simpleClassTypeSignature(classRef(binaryName()))
         Some(classTypeSignatureRest(pre))
       else None
     end classTypeSignature
@@ -279,7 +294,7 @@ private[classfiles] object JavaSignatures:
         classRest(null)
 
     def fieldSignature: Type =
-      referenceType(null)
+      baseType.getOrElse(referenceType(null))
 
     def cookFailure(tname: TypeName, reason: String): Nothing =
       val path = if !isClass then s"${member.owner.displayFullName}#${member.name}" else member.displayFullName