Macro does not always elide its receiver

[allanrenucci]

Let's consider the following macro based string interpolator

import scala.quoted._
import scala.tasty.Tasty

object Macro {
  class StringContextOps(sc: StringContext) {
    rewrite def ff(args: => Any*): String = ~Macro.impl('(sc), '(args))
  }
  implicit rewrite def XmlQuote(sc: => StringContext): StringContextOps = new StringContextOps(sc)
  def impl(sc: Expr[StringContext], args: Expr[Seq[Any]])(implicit tasty: Tasty): Expr[String] = '("")
}

And the following use case:

class Test {
  import Macro._
  def test = ff"Hello World"
}

which expands to:

class Test {
  def test: String = {
    // start dead code
    val $1$: Macro.Macro$StringContextOps =
      new Macro.Macro$StringContextOps(
        _root_.scala.StringContext.apply(
          Predef.wrapRefArray(["Hello World" : String])
        )
      )
    // end dead code

    // expansion
    ""
  }
}

My expectation (and how it works in Scala 2) is that the receiver of the macro gets elided

[sjrd]

The receiver is not by-name, so it cannot be elided.

[nicolasstucki]

In general we must not elide the receiver or else we would change the semantics function application.

[allanrenucci]

Even if it is by-name, is it not elided:

class Test {
  def test(): String = {
    val $1$: Macro.Macro$StringContextOps = 
      new Macro.Macro$StringContextOps(
        {
          closure(<empty>.this.$anonfun$1:Function0)
        }
      )
    ""
  }

  private final <static> def $anonfun$1(): StringContext = 
    root_.scala.StringContext.apply(
      Predef.wrapRefArray(["Hello World" : String])
    )
}

But when I write:

class Foo {
  rewrite def foo: String = ~Macro.impl
}

object Macro {
  def impl: Expr[String] = '("")
}

class Test {
  def test = (new Foo).foo
}

The full call to the macro foo is elided provided that the constructor of Foo is pure

[nicolasstucki]

Previously we did rely on the optimizer to remove the remaining unused val with no side effects on the RHS. I will have a look at those details. Maybe we should have a minimal DCE optimization for inlined methods.