Question

假设我有一个Generic超类：

class GenericExample[T](
                         a: String,
                         b: T
                       ) {

  def fn(i: T): T = b
}

和一个具体的子类：

case class Example(
                    a: String,
                    b: Int
                  ) extends GenericExample[Int](a, b)

我想通过scala反射得到函数“fn”的类型参数，所以我选择并过滤其成员：

import ScalaReflection.universe._

val baseType = typeTag[Example]

val member = baseType
  .tpe
  .member(methodName: TermName)
  .asTerm
  .alternatives
  .map(_.asMethod)
  .head

    val paramss = member.paramss
    val actualTypess: List[List[Type]] = paramss.map {
      params =>
        params.map {
          param =>
            param.typeSignature
        }
    }

我期待scala给我正确的结果，List(List(Int))，而我只得到通用的List(List(T))

通过文档进行处理我发现typeSignature是罪魁祸首：

 *  This method always returns signatures in the most generic way possible, even if the underlying symbol is obtained from an
 *  instantiation of a generic type.

它建议我使用替代方案：

def typeSignatureIn(site: Type): Type

但是，由于类示例不再是通用的，我无法从typeTag获取网站[示例]，任何人都可以建议我如何获得typeOf [Int]仅给出typeTag [示例]？或者没有办法做到这一点我必须恢复到Java反射？

非常感谢你的帮助。

更新经过一些快速测试后，我发现即使 MethodSymbol.returnType 也无法正常工作，代码如下：

member.returnType

也会产生T，并且 asSeenFrom 无法更正，因为以下代码不会更改结果：

member.returnType.asSeenFrom(baseType.tpe, baseType.tpe.typeSymbol.asClass)

Answer 1

我可以建议两种方法：

1）从基类中显示泛型类型：

import scala.reflect.runtime.universe._

class GenericExample[T: TypeTag](a: String, b: T) {
  def fn(i: T) = "" + b + i
}

case class Example(a: String, b: Int) extends GenericExample[Int](a, b) {}

val classType = typeOf[Example].typeSymbol.asClass
val baseClassType = typeOf[GenericExample[_]].typeSymbol.asClass
val baseType = internal.thisType(classType).baseType(baseClassType)

baseType.typeArgs.head // returns reflect.runtime.universe.Type = scala.Int

2）添加返回类型的隐式方法：

import scala.reflect.runtime.universe._

class GenericExample[T](a: String, b: T) {
  def fn(i: T) = "" + b + i
}

case class Example(a: String, b: Int) extends GenericExample[Int](a, b)

implicit class TypeDetector[T: TypeTag](related: GenericExample[T]) {
  def getType(): Type = {
    typeOf[T]
  }
}

new Example("", 1).getType() // returns reflect.runtime.universe.Type = Int

Answer 2

我正在发布我的解决方案：我认为由于Scala的设计，没有其他选择：

Scala反射和方法之间的核心区别Java反射正在讨论：Scala方法由多对括号组成，调用带参数的方法首先只构造一个可以使用更多对括号的匿名类，或者如果没有更多的括号，则构造一个NullaryMethod类（也称为call-）可以解析以产生方法的结果。所以scala方法的类型只在这个级别解决，当方法已经分解为Method＆amp; NullaryMethod签名。

结果很明显，结果类型只能使用递归：

  private def methodSignatureToParameter_ReturnTypes(tpe: Type): (List[List[Type]], Type) = {
    tpe match {
      case n: NullaryMethodType =>
        Nil -> n.resultType
      case m: MethodType =>
        val paramTypes: List[Type] = m.params.map(_.typeSignatureIn(tpe))
        val downstream = methodSignatureToParameter_ReturnTypes(m.resultType)
        downstream.copy(_1 = List(paramTypes) ++ methodSignatureToParameter_ReturnTypes(m.resultType)._1)
      case _ =>
        Nil -> tpe
    }
  }

  def getParameter_ReturnTypes(symbol: MethodSymbol, impl: Type) = {

    val signature = symbol.typeSignatureIn(impl)
    val result = methodSignatureToParameter_ReturnTypes(signature)
    result
  }

impl是拥有该方法的类，而symbol是您通过scala反射从Type.member(s)获得的内容

在Scala Reflection中，如何获取具体子类的泛型类型参数？

2 个答案: