Unused temporary for lonely vararg in named args rewrite

[som-snytt]

reproduction steps

object t7 {
  def f(a: Int, b: String*) = "first"
}
object Test extends App {
  println(t7.f(1))
  println(t7.f(a = 19))
  println(t7.f(a = 28, b = "sl19"))
  println(t7.f(b = "sl19", a = 28))
}

problem

$ scalac -Xlint unused-fresh.scala
unused-fresh.scala:8: warning: local val x$1 in value <local Test> is never used
  println(t7.f(b = "sl19", a = 28))
                   ^
one warning found

where

      scala.Predef.println({
        <artifact> val x$1: Seq = scala.collection.immutable.Seq.apply(scala.runtime.ScalaRunTime.wrapRefArray(Array[String]{"sl19"}.$asInstanceOf[Array[Object]]())).$asInstanceOf[Seq]();
        <artifact> val x$2: Int(28) = 28;
        t7.f(28, scala.runtime.ScalaRunTime.wrapRefArray(Array[String]{"sl19"}.$asInstanceOf[Array[Object]]()))
      });

expectation

Less cruft.

[dwijnand]

Weird. I kind of expected b = "sl19" to not compile. Were you expecting it to? Does the spec say anything about that?

Also, why isn't x$2 similarly unused?

[som-snytt]

Guessing that x$2 is not used because it's a constant, and not flagged unused for same reason. Non-constant expr is used.

The way to avoid disappointment is not to have expectations.

I did recently see a behavioral difference in Scala 3, that you can't name a sequence arg out-of-order, though the issue was deemed too low-priority to track at scala/scala3#10220.

Pushing expectations:

scala> def f(a: Int, b: String*) = "first"
def f(a: Int, b: String*): String

scala> f(b = "x", a = 42)
val res0: String = first

scala> f(b = "x", b = "y", a = 42)   // not beyond the pale
                    ^
       error: parameter 'b' is already specified at parameter position 1

scala> f(b = "x"::"y"::Nil:_*, a = 42)   // not in dotty you don't
val res2: String = first

scala>

Edit: looks like the issue is only with single arg supplied to varargs.

[dwijnand]

It's an Xlint unused concern, no?

[som-snytt]

I removed lint label because it's an extra allocation. That is, the lint is correct, it's the compiler that is wrong.

I was just checking the byte code, which creates a list x :: Nil for the temporary, then allocates an array that is wrapped for the arg.

Edit: there's the perspective not to lint something that isn't the user's fault. No advice is given how to avoid it here.

[dwijnand]

Ah, I see your reasoning now. Yeah, silly macro, leaving cruft around.

[dwijnand]

Another version (reported at #12239), where even a simple usage of the varargs emits the warning:

reproduction steps

using Scala 2.13.3

object Hmm {
  def zxc(b: Int*)(implicit x: Int = 3) = "" + b + x
  zxc(4)
}

problem

> scalac -Xlint as.scala
as.scala:3: warning: local val x$1 in value <local Hmm> is never used
  zxc(4)
      ^
1 warning