Типы, зависящие от пути и вложенные черты

Фон

Предположим, что у меня есть некоторые вложенные черты:

trait Foo { trait Bar }

И несколько примеров:

val myFoo = new Foo {}
val myBar = new myFoo.Bar {}

Я могу написать следующее, которые выглядят (по крайней мере с первого взгляда), как будто они должны делать более или менее одно и то же:

def whatever1(foo: Foo)(bar: foo.Bar) = bar
def whatever2(foo: Foo): foo.Bar => foo.Bar = { bar => bar }
def whatever3(foo: Foo) = new { def apply(bar: foo.Bar) = bar }
case class whatever4(foo: Foo) { def apply(bar: foo.Bar) = bar }
case class whatever5[F <: Foo](foo: F) { def apply(bar: foo.Bar) = bar }

Обратите внимание, что последнее вдохновлено решением, заданным здесь.

Первые три работы:

scala> val sameBar1: myFoo.Bar = whatever1(myFoo)(myBar)
sameBar1: myFoo.Bar = [email protected]

scala> val sameBar2: myFoo.Bar = whatever2(myFoo)(myBar)
sameBar1: myFoo.Bar = [email protected]

scala> val sameBar3: myFoo.Bar = whatever3(myFoo)(myBar)
sameBar2: myFoo.Bar = [email protected]

Но не четвертый или пятый:

scala> val sameBar4: myFoo.Bar = whatever4(myFoo)(myBar)
<console>:12: error: type mismatch;
 found   : myFoo.Bar
 required: _1.foo.Bar where val _1: whatever4
       val sameBar4: myFoo.Bar = whatever4(myFoo)(myBar)
                                                  ^

Достаточно справедливо - мы не можем сделать следующее, вероятно, по тем же причинам:

scala> val myOof = myFoo
myOof: Foo = [email protected]

scala> val myOofBar: myOof.Bar = new myFoo.Bar {}
<console>:10: error: type mismatch;
 found   : myFoo.Bar
 required: myOof.Bar
       val myOofBar: myOof.Bar = new myFoo.Bar {}
                                 ^

И это не очень важно, так как у нас есть три рабочих решения.

Проблема

(Я начну с того, отметив, что, хотя я впервые столкнулся с проблемой ниже при работе с макросами, и хотя мой пример здесь включает API отражения, мой вопрос не специфичен для макросов или отражений.)

Предположим, что я работаю с новым API отражения и хочу иметь возможность написать следующее:

applier[List[_]](Literal(Constant(42)), Literal(Constant(13)))

И имеет ли это что-то вроде "дайте мне абстрактное синтаксическое дерево для List(42, 13)". Это не слишком сложно - я могу просто использовать подход от whatever3 выше:

trait ReflectionUtils {
  import scala.reflect.api.Universe
 
  def companionApplier(u: Universe) = new {
    def apply[A: u.TypeTag](xs: u.Tree*): u.Tree = u.Apply(
      u.Select(u.Ident(u.typeOf[A].typeSymbol.companionSymbol), "apply"),
      xs.toList
    )
  }
}

И теперь я получаю синтаксис, который я хочу в своих макросах (см. answer to this вопрос для более подробного и мотивированного примера):

object MacroExample extends ReflectionUtils {
  import scala.language.experimental.macros
  import scala.language.reflectiveCalls
  import scala.reflect.macros.Context

  def threeOfThem(n: Int) = macro threeOfThem_impl
  def threeOfThem_impl(c: Context)(n: c.Expr[Int]) = {
    val applier = companionApplier(c.universe)

    c.Expr[List[Int]](applier[List[_]](n.tree, n.tree, n.tree))
  }
}

И все работает по назначению. Мне не очень нравится "рефлексивный доступ к структурному типу". К сожалению, я не могу использовать подходы whatever1 или whatever2 здесь, так как я не могу исправить параметр типа при применении этой вещи к моей вселенной. Мне бы хотелось написать следующее:

case class companionApplier(u: Universe) {
  def apply[A: u.TypeTag](xs: u.Tree*): u.Tree = u.Apply(
    u.Select(u.Ident(u.typeOf[A].typeSymbol.companionSymbol), "apply"),
    xs.toList
  )
}

Но это, конечно, заводит меня в проблемы несоответствия типа, которые мы видели с помощью whatever4 выше.

Есть ли какой-то другой трюк, который мне не хватает? Возможно ли получить синтаксис, который я хочу, без использования анонимного класса со структурным членом?