Adapt tasty-reflect for the changes in Signature

Further work to present a nicer API for Signature might be needed.

Author: smarter

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -1398,8 +1398,13 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   type Signature = core.Signature
 
-  def Signature_paramSigs(self: Signature): List[String] =
-    self.paramsSig.map(_.toString)
+  def Signature_paramSigs(self: Signature): List[String | Int] =
+    self.paramsSig.map {
+      case paramSig: core.Names.TypeName =>
+        paramSig.toString
+      case paramSig: Int =>
+        paramSig
+    }
 
   def Signature_resultSig(self: Signature): String =
     self.resSig.toString

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -1121,13 +1121,10 @@ trait CompilerInterface {
   // SIGNATURES
   //
 
-  /** JVM signature of a method */
   type Signature <: AnyRef
 
-  /** The (JVM) erased signatures of the parameters */
-  def Signature_paramSigs(self: Signature): List[String]
+  def Signature_paramSigs(self: Signature): List[String | Int]
 
-  /** The (JVM) erased result type */
   def Signature_resultSig(self: Signature): String
 
   //

library/src/scala/tasty/reflect/Core.scala

@@ -400,7 +400,7 @@ trait Core {
   /** Untyped identifier */
   type Id = internal.Id
 
-  /** JVM signature of a method */
+  /** Signature of a method */
   type Signature = internal.Signature
 
   /** Position in a source file */

library/src/scala/tasty/reflect/Printers.scala

@@ -356,7 +356,7 @@ trait Printers
 
       def visitSignature(sig: Signature): Buffer = {
         val Signature(params, res) = sig
-        this += "Signature(" ++= params += ", " += res += ")"
+        this += "Signature(" ++= params.map(_.toString) += ", " += res += ")"
       }
 
       def visitImportSelector(sel: ImportSelector): Buffer = sel match {

library/src/scala/tasty/reflect/SignatureOps.scala

@@ -2,19 +2,25 @@ package scala.tasty.reflect
 
 trait SignatureOps extends Core {
 
-  /** Erased (JVM) signatures. */
+  /** The signature of a method */
   object Signature {
-    /** Matches the erased (JVM) signature and returns its parameters and result type. */
-    def unapply(sig: Signature) given (ctx: Context): Option[(List[String], String)] =
+    /** Matches the method signature and returns its parameters and result type. */
+    def unapply(sig: Signature) given (ctx: Context): Option[(List[String | Int], String)] =
       Some((sig.paramSigs, sig.resultSig))
   }
 
   implicit class SignatureAPI(sig: Signature) {
 
-    /** The (JVM) erased signatures of the parameters */
-    def paramSigs: List[String]= internal.Signature_paramSigs(sig)
+    /** The signatures of the method parameters.
+      *
+      *  Each *type parameter section* is represented by a single Int corresponding
+      *  to the number of type parameters in the section.
+      *  Each *term parameter* is represented by a String corresponding to the fully qualified
+      *  name of the parameter type.
+      */
+    def paramSigs: List[String | Int] = internal.Signature_paramSigs(sig)
 
-    /** The (JVM) erased result type */
+    /** The signature of the result type */
     def resultSig: String = internal.Signature_resultSig(sig)
 
   }

tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala

@@ -81,34 +81,35 @@ class JVMReflection[R <: Reflection & Singleton](val reflect: R) {
   }
 
   private def paramsSig(sym: Symbol): List[Class[_]] = {
-    sym.asDefDef.signature.paramSigs.map { param =>
-      def javaArraySig(name: String): String = {
-        if (name.endsWith("[]")) "[" + javaArraySig(name.dropRight(2))
-        else name match {
-          case "scala.Boolean" => "Z"
-          case "scala.Byte" => "B"
-          case "scala.Short" => "S"
-          case "scala.Int" => "I"
-          case "scala.Long" => "J"
-          case "scala.Float" => "F"
-          case "scala.Double" => "D"
-          case "scala.Char" => "C"
-          case paramName => "L" + paramName + ";"
+    sym.asDefDef.signature.paramSigs.collect {
+      case param: String =>
+        def javaArraySig(name: String): String = {
+          if (name.endsWith("[]")) "[" + javaArraySig(name.dropRight(2))
+          else name match {
+            case "scala.Boolean" => "Z"
+            case "scala.Byte" => "B"
+            case "scala.Short" => "S"
+            case "scala.Int" => "I"
+            case "scala.Long" => "J"
+            case "scala.Float" => "F"
+            case "scala.Double" => "D"
+            case "scala.Char" => "C"
+            case paramName => "L" + paramName + ";"
+          }
         }
-      }
-
-      def javaSig(name: String): String =
-        if (name.endsWith("[]")) javaArraySig(name) else name
-
-      if (param == "scala.Boolean") classOf[Boolean]
-      else if (param == "scala.Byte") classOf[Byte]
-      else if (param == "scala.Char") classOf[Char]
-      else if (param == "scala.Short") classOf[Short]
-      else if (param == "scala.Int") classOf[Int]
-      else if (param == "scala.Long") classOf[Long]
-      else if (param == "scala.Float") classOf[Float]
-      else if (param == "scala.Double") classOf[Double]
-      else java.lang.Class.forName(javaSig(param), false, classLoader)
+
+        def javaSig(name: String): String =
+          if (name.endsWith("[]")) javaArraySig(name) else name
+
+        if (param == "scala.Boolean") classOf[Boolean]
+        else if (param == "scala.Byte") classOf[Byte]
+        else if (param == "scala.Char") classOf[Char]
+        else if (param == "scala.Short") classOf[Short]
+        else if (param == "scala.Int") classOf[Int]
+        else if (param == "scala.Long") classOf[Long]
+        else if (param == "scala.Float") classOf[Float]
+        else if (param == "scala.Double") classOf[Double]
+        else java.lang.Class.forName(javaSig(param), false, classLoader)
     }
   }