Handle recursive types involving type aliases (#242)

* Add a test for generating surface of recursive types involving type aliases

* Support type alias of higher kind types

* Fix higher kind type reference in Scala.js

Author: xerial

airframe-surface/js/src/main/scala/wvlet/surface/SurfaceMacros.scala

@@ -115,7 +115,15 @@ private[surface] object SurfaceMacros {
           if symbol.isType &&
             symbol.asType.isAliasType &&
             !belongsToScalaDefault(alias) =>
-        val inner    = surfaceOf(alias.dealias)
+        val dealiased = alias.dealias
+        val inner = if (alias != dealiased) {
+          surfaceOf(dealiased)
+        } else {
+          // When higher kind types are aliased (e.g., type M[A] = Future[A]),
+          // alias.dealias will not return the aliased type (Future[A]),
+          // So we need to find the resulting type by applying type erasure.
+          surfaceOf(alias.erasure)
+        }
         val name     = symbol.asType.name.decodedName.toString
         val fullName = s"${prefix.typeSymbol.fullName}.${name}"
         q"wvlet.surface.Alias(${name}, ${fullName}, $inner)"
@@ -399,7 +407,15 @@ private[surface] object SurfaceMacros {
       case t @ TypeRef(NoPrefix, symbol, args) if !t.typeSymbol.isClass =>
         q"wvlet.surface.ExistentialType"
       case t =>
-        val expr = q"new wvlet.surface.GenericSurface(classOf[$t])"
+        val finalType =
+          if (t.typeSymbol.asType.isAbstract && !(t =:= typeOf[AnyRef])) {
+            // Use M[_] for type M
+            t.erasure
+          } else {
+            t
+          }
+
+        val expr = q"new wvlet.surface.GenericSurface(classOf[${finalType}])"
         expr
     }
 

airframe-surface/jvm/src/main/scala/wvlet/surface/reflect/SurfaceFactory.scala

@@ -260,10 +260,20 @@ object SurfaceFactory extends LogSupport {
           if symbol.isType &&
             symbol.asType.isAliasType &&
             !belongsToScalaDefault(alias) =>
-        val inner    = surfaceOf(alias.dealias)
+        val dealiased = alias.dealias
+        val inner = if (alias != dealiased) {
+          surfaceOf(dealiased)
+        } else {
+          // When higher kind types are aliased (e.g., type M[A] = Future[A]),
+          // alias.dealias will not return the aliased type (Future[A]),
+          // So we need to find the resulting type by applying type erasure.
+          surfaceOf(alias.erasure)
+        }
+
         val name     = symbol.asType.name.decodedName.toString
         val fullName = s"${prefix.typeSymbol.fullName}.${name}"
-        Alias(name, fullName, inner)
+        val a        = Alias(name, fullName, inner)
+        a
     }
 
     private def arrayFactory: SurfaceMatcher = {

airframe-surface/shared/src/main/scala/wvlet/surface/Surfaces.scala

@@ -13,7 +13,6 @@
  */
 package wvlet.surface
 import scala.language.existentials
-import scala.reflect.runtime.{universe => ru}
 
 /**
   * Parameters of a Surface

airframe-surface/shared/src/test/scala/wvlet/surface/RecursiveHigherKindTypeTest.scala

@@ -0,0 +1,46 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package wvlet.surface
+import wvlet.surface
+import scala.language.higherKinds
+
+object RecursiveHigherKindTypeTest {
+  trait Holder[M[_]]
+
+  class MyTask[A]
+
+  object Holder {
+    type BySkinny[A] = MyTask[A]
+    def bySkinny: Holder[BySkinny] = new InterpretedHolder
+  }
+
+  import Holder._
+  class InterpretedHolder extends Holder[BySkinny] {}
+}
+
+/**
+  *
+  */
+class RecursiveHigherKindTypeTest extends SurfaceSpec {
+  import RecursiveHigherKindTypeTest._
+  import Holder.BySkinny
+
+  "Surface" should {
+    "support recursive higher kind types" in {
+      val s = surface.of[Holder[BySkinny]]
+      s.name shouldBe "Holder[BySkinny]"
+      s.typeArgs(0).dealias.name shouldBe "MyTask[_]"
+    }
+  }
+}

airframe-surface/shared/src/test/scala/wvlet/surface/RecursiveSurfaceTest.scala

@@ -19,7 +19,6 @@ object RecursiveSurfaceTest {
 
   case class Leaf(name: String)
   case class Cons(head: String, tail: Cons)
-
   case class TypedCons[A](head: String, tail: TypedCons[A])
 
 }
@@ -71,5 +70,4 @@ class RecursiveSurfaceTest extends SurfaceSpec {
       lazyC.isOption shouldBe false
     }
   }
-
 }

airframe/src/test/scala/wvlet/airframe/HigherKindTypeTest.scala

@@ -15,14 +15,12 @@ package wvlet.airframe
 import scala.language.higherKinds
 
 object HigherKindTypeTest {
-
   trait Holder[M[_]] {
     def hello = "hello"
   }
 
   trait Task[A]
   trait MyFuture[A]
-
   trait HolderInterpreted extends Holder[Task]
 
   val interpreted = new HolderInterpreted {
@@ -47,7 +45,6 @@ class HigherKindTypeTest extends AirframeSpec {
       .noLifeCycleLogging
 
   "Airframe" should {
-
     "support higher kind types" in {
       design.build[HolderInterpreted] { repo =>
         repo.hello shouldBe "new interpretation"