Read Java parameter names.

Author: sjrd

build.sbt

@@ -68,6 +68,7 @@ lazy val testSources = crossProject(JSPlatform, JVMPlatform)
   .settings(
     publish / skip := true,
     scalacOptions += "-Xfatal-warnings",
+    javacOptions += "-parameters",
   )
 
 lazy val tastyQuery =

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

@@ -219,14 +219,19 @@ private[reader] object ClassfileParser {
       val sym = TermSymbol.create(name, owner)
       allRegisteredSymbols += sym
 
+      // Read parameter names
+      val methodParamNames =
+        if isMethod then readMethodParameters(attributes).map(_._1)
+        else Nil
+
       // Find the signature, or fall back to the descriptor
       val memberSig = attributes.get(attr.Signature) match
         case Some(stream) => stream.use(ClassfileReader.readSignature)
         case None         => descriptor
 
       // Parse the signature into a declared type for the symbol
       val declaredType =
-        val parsedType = JavaSignatures.parseSignature(sym, isMethod, memberSig, allRegisteredSymbols)
+        val parsedType = JavaSignatures.parseSignature(sym, isMethod, methodParamNames, memberSig, allRegisteredSymbols)
         val adaptedType =
           if isMethod && sym.name == nme.Constructor then cls.makePolyConstructorType(parsedType)
           else if isMethod && javaFlags.isVarargsIfMethod then patchForVarargs(sym, parsedType)
@@ -295,7 +300,9 @@ private[reader] object ClassfileParser {
       val parents = attributes.get(attr.Signature) match
         case Some(stream) =>
           val sig = stream.use(ClassfileReader.readSignature)
-          JavaSignatures.parseSignature(cls, isMethod = false, sig, allRegisteredSymbols).requireType match
+          val parsedSig =
+            JavaSignatures.parseSignature(cls, isMethod = false, methodParameterNames = Nil, sig, allRegisteredSymbols)
+          parsedSig.requireType match
             case mix: AndType => mix.parts
             case sup          => sup :: Nil
         case None =>
@@ -367,6 +374,14 @@ private[reader] object ClassfileParser {
           None
   end ArrayTypeExtractor
 
+  private def readMethodParameters(attributes: AttributeMap)(
+    using ConstantPool
+  ): List[(UnsignedTermName, AccessFlags)] =
+    attributes.get(attr.MethodParameters) match
+      case Some(stream) => stream.use(ClassfileReader.readMethodParameters())
+      case None         => Nil
+  end readMethodParameters
+
   private def readAnnotations(
     sym: TermOrTypeSymbol,
     attributes: AttributeMap

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

@@ -296,6 +296,24 @@ private[reader] object ClassfileReader {
     result
   end readAttribute
 
+  def readMethodParameters()(using ds: DataStream, pool: ConstantPool): List[(UnsignedTermName, AccessFlags)] =
+    val numParameters = data.readU1()
+    val resultBuilder = List.newBuilder[(UnsignedTermName, AccessFlags)]
+
+    var index = 0
+    while index != numParameters do
+      val nameIndex = data.readU2()
+      val name =
+        if nameIndex == 0 then UniqueName(termName("x"), "$", index)
+        else pool.utf8(pool.idx(nameIndex))
+      val accessFlags = AccessFlags.read(data.readU2())
+      resultBuilder += ((name, accessFlags))
+      index += 1
+    end while
+
+    resultBuilder.result()
+  end readMethodParameters
+
   def readAnnotation(typeDescriptors: Set[SimpleName])(using ds: DataStream, pool: ConstantPool): Option[Annotation] = {
     // pre: we are already inside the RuntimeVisibleAnnotations attribute
 

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

@@ -8,6 +8,7 @@ private[classfiles] object Constants:
     val Scala = termName("Scala")
     val ScalaSig = termName("ScalaSig")
     val InnerClasses = termName("InnerClasses")
+    val MethodParameters = termName("MethodParameters")
     val RuntimeVisibleAnnotations = termName("RuntimeVisibleAnnotations") // RetentionPolicy.RUNTIME
     val RuntimeInvisibleAnnotations = termName("RuntimeInvisibleAnnotations") // RetentionPolicy.CLASS
     val RuntimeVisibleParameterAnnotations = termName("RuntimeVisibleParameterAnnotations")

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

@@ -82,6 +82,7 @@ private[classfiles] object JavaSignatures:
   def parseSignature(
     member: TermOrTypeSymbol,
     isMethod: Boolean,
+    methodParameterNames: List[UnsignedTermName],
     signature: String,
     allRegisteredSymbols: Growable[TermOrTypeSymbol]
   )(using ReaderContext, InnerClasses, Resolver): TypeOrMethodic =
@@ -294,13 +295,20 @@ private[classfiles] object JavaSignatures:
     def termParamsRest(env: JavaSignature): List[Type] =
       readUntil(')', javaTypeSignature(env))
 
+    def uniqueParamNames(count: Int): List[UnsignedTermName] =
+      val underlying = termName("x")
+      (0 until count).toList.map(i => UniqueName(underlying, "$", i))
+
     def methodSignature: MethodicType =
       def methodRest(env: JavaSignature): MethodType =
         if consume('(') then // must have '(', ')', and return type
           val params = termParamsRest(env)
           val ret = result(env)
           val _ = readWhile('^', throwsSignatureRest(env)) // ignore throws clauses
-          MethodType((0 until params.size).map(i => termName(s"x$$$i")).toList, params, ret)
+          val paramNames =
+            if methodParameterNames.isEmpty && params.nonEmpty then uniqueParamNames(params.size)
+            else methodParameterNames
+          MethodType(paramNames, params, ret)
         else abort
       if consume('<') then
         PolyType(lookaheadTypeParamNames)(

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

@@ -707,6 +707,12 @@ class TypeSuite extends UnrestrictedUnpicklingSuite {
       assert(tpe.resultType.isArrayOf(_.isRef(JavaDefinedClass)))
     }
 
+    testDef(termName("multipleArguments")) { multipleArguments =>
+      assertJavaPublic(multipleArguments)
+      val tpe = multipleArguments.declaredType.asInstanceOf[MethodType]
+      assert(clue(tpe.paramNames) == List(termName("foo"), termName("bar"), termName("foobar")))
+    }
+
     testDef(name"processBuilder") { processBuilder =>
       assertJavaPublic(processBuilder)
       val tpe = processBuilder.declaredType.asInstanceOf[MethodType]

test-sources/src/main/scala/javadefined/BagOfJavaDefinitions.java

@@ -47,6 +47,10 @@ public javadefined.JavaDefined[] arrIdentity(javadefined.JavaDefined[] arr) {
     return arr;
   }
 
+  public int multipleArguments(int foo, boolean bar, String foobar) {
+    return foo;
+  }
+
   public java.lang.ProcessBuilder processBuilder() {
     return new ProcessBuilder("echo");
   }