Export clauses drop varargs on inline methods

[CiaraOBrien]

On 3.0.0-M2:

Minimized code

object Exporter {
  object Exportee {
    inline def foo(args: String*): String = args.mkString(" ")
  }
  export Exportee._
}
import Exporter._
foo("a", "b", "c")

Output

1 |foo("a", "b", "c")
  |    ^^^^^^^^^^^^^
  |    Found:    (args$proxy1 : Seq[String])
  |    Required: String

Expectation

val res0: String = a b c

[CiaraOBrien]

This also occurs with the obvious workaround:

object Exporter {
  object Exportee {
    inline def foo(args: String*): String = args.mkString(" ")
  }
  export Exportee.{foo => _, _}
  inline def foo(args: String*): String = Exportee.foo(args)
}
import Exporter._
foo("a", "b", "c")

or

object Exporter {
  object Exportee {
    inline def foo(args: String*): String = args.mkString(" ")
  }
  inline def foo(args: String*): String = Exportee.foo(args)
}
import Exporter._
foo("a", "b", "c")

Both yield:

6 |  inline def foo(args: String*): String = Exportee.foo(args)
  |                                                       ^^^^
  |                                  Found:    (args : Seq[String] @Repeated)
  |                                  Required: String

[CiaraOBrien]

Of course,

object Exporter {
  object Exportee {
    inline def foo(args: String*): String = args.mkString(" ")
  }
}
import Exporter.Exportee._
foo("a", "b", "c")

Yields the desired outcome.

[CiaraOBrien]

Ah, nevermind, this is just my own idiocy, I forgot that varargs need to be ascribed back into themselves:

object Exporter {
  object Exportee {
    inline def foo(args: String*): String = args.mkString(" ")
  }
  inline def foo(args: String*): String = Exportee.foo(args: _*)
}
import Exporter._
foo("a", "b", "c")

[CiaraOBrien]

No, actually, this is still definitely an issue, because export clauses still don't work, on account of not doing that ascription. Ideally the compiler should be able to perform that automatically so inline varargs methods actually work across export clauses.

[CiaraOBrien]

The correct workaround, leaving the rest of the export clause in place, is:

object Exporter {
  object Exportee {
    inline def foo(args: String*): String = args.mkString(" ")
  }
  export Exportee.{foo => _, _}
  inline def foo(args: String*): String = Exportee.foo(args: _*)
}
import Exporter._
foo("a", "b", "c")

[CiaraOBrien]

Wild guess, going off very little knowledge of the compiler's internals, the solution might be to do something like
this, but
here. Map parameter lists with elements for which hasAnnotation(defn.VarargsAnnot) is true with tpd.repeated before applying ref to them, or something like that.