airframe-surface: Scala 3: Pass all tests on JVM (#2052)

* Handle case fields as method arguments

wvlet.airframe.surface.MultipleConstructorArgsTest
wvlet.airframe.surface.ClassSurfaceTest

* Fix confusion of List[String] wand String

Fix wvlet.airframe.surface.RecursiveSurfaceTest

* Treat type parameter such as T

Fix  wvlet.airframe.surface.RecursiveHigherKindTypeTest

* Different key for type params to avoid cache collision

fix wvlet.airframe.surface.RecursiveHigherKindTypeTest

* Different key for type bounds

fix wvlet.airframe.surface.reflect.RuntimeSurfaceTest
fix wvlet.airframe.surface.SurfaceTest

Author: exoego

airframe-surface/src/main/scala-3/wvlet/airframe/surface/CompileTimeSurfaceFactory.scala

@@ -1,5 +1,6 @@
 package wvlet.airframe.surface
 import scala.quoted._
+import dotty.tools.dotc.core.{Types as DottyTypes}
 
 private[surface] object CompileTimeSurfaceFactory {
 
@@ -47,17 +48,19 @@ private[surface] class CompileTimeSurfaceFactory[Q <: Quotes](using quotes: Q) {
 
   private def fullTypeNameOf(t: TypeRepr): String = {
     def sanitize(symbol: Symbol): String = {
-      val name = symbol.fullName.split("\\.").toList match {
+      val nameParts: List[String] = symbol.fullName.split("\\.").toList match {
         case "scala" :: "Predef$" :: tail =>
-          tail.mkString(".")
+          tail
         case "scala" :: "collection" :: "immutable" :: tail =>
-          tail.mkString(".")
+          tail
         case "scala" :: nme :: Nil =>
-          nme
+          List(nme)
         case other =>
           other
       }
-      name.toString.stripSuffix("$").replaceAll("\\.package\\$", ".").replaceAll("\\$+", ".")
+      nameParts
+        .mkString(".").stripSuffix("$").replaceAll("\\.package\\$", ".").replaceAll("\\$+", ".")
+        .replaceAll("\\.\\.", ".")
     }
     t match {
       case a: AppliedType if a.args.nonEmpty =>
@@ -89,7 +92,18 @@ private[surface] class CompileTimeSurfaceFactory[Q <: Quotes](using quotes: Q) {
       // For debugging
       // println(s"[${typeNameOf(t)}]\n  ${t}")
       val generator = factory.andThen { expr =>
-        '{ wvlet.airframe.surface.surfaceCache.getOrElseUpdate(${ Expr(fullTypeNameOf(t)) }, ${ expr }) }
+        val cacheKey =
+          if (typeNameOf(t) == "scala.Any" && classOf[DottyTypes.TypeBounds].isAssignableFrom(t.getClass)) {
+            // Distinguish scala.Any and type bounds (such as _)
+            s"${fullTypeNameOf(t)} for ${t}"
+          } else if (typeNameOf(t) == "scala.Any" && classOf[DottyTypes.TypeParamRef].isAssignableFrom(t.getClass)) {
+            // This ensure different cache key for each Type Parameter (such as T and U).
+            // This is required because fullTypeNameOf of every Type Parameters is `scala.Any`.
+            s"${fullTypeNameOf(t)} for ${t}"
+          } else {
+            fullTypeNameOf(t)
+          }
+        '{ wvlet.airframe.surface.surfaceCache.getOrElseUpdate(${ Expr(cacheKey) }, ${ expr }) }
       }
       val surface = generator(t)
       // println(s"--- ${surface.show}")
@@ -110,6 +124,7 @@ private[surface] class CompileTimeSurfaceFactory[Q <: Quotes](using quotes: Q) {
       javaEnumFactory orElse
       exisitentialTypeFactory orElse
       genericTypeWithConstructorFactory orElse
+      typeParameterFactory orElse
       genericTypeFactory
   }
 
@@ -260,6 +275,12 @@ private[surface] class CompileTimeSurfaceFactory[Q <: Quotes](using quotes: Q) {
       }
   }
 
+  private def typeParameterFactory: Factory = {
+    case p: DottyTypes.ParamRef if (fullTypeNameOf(p) == "Any") =>
+      val paramName = Expr(p.paramName.toString)
+      '{ HigherKindedTypeSurface(${ paramName }, ${ paramName }, AnyRefSurface, Nil) }
+  }
+
   private def genericTypeFactory: Factory = {
     case a: AppliedType =>
       val typeArgs = a.args.map(surfaceOf(_))

airframe-surface/src/test/scala/wvlet/airframe/surface/SurfaceTest.scala

@@ -184,6 +184,7 @@ class SurfaceTest extends SurfaceSpec {
   }
 
   test("resolve generic abstract type") {
+    assertEquals(Surface.of[D[_]].typeArgs, Seq(ExistentialType))
     val d = check(Surface.of[D[_]], "D[_]")
     assertEquals(d.typeArgs.length, 1)
     check(Surface.of[Map[_, _]], "Map[_,_]")