Plugin which summons an implicit

[adamw]

Hello,

I'm trying to write a compiler plugin which would try summoning an implicit at certain applications (Apply trees). After many trial&errors I did find typer.inferImplicit, however this seems to work only in a limited number of cases. Here's the plugin code that I have (simplified):

class MyPlugin extends StandardPlugin:
  val name: String = "myPlugin"
  override val description: String = "My Plugin"

  def init(options: List[String]): List[PluginPhase] =
    (new MyPluginPhase) :: Nil

class MyPluginPhase extends PluginPhase:
  import tpd.*

  val phaseName = "myPlugin"

  override val runsAfter: Set[String] = Set(PostTyper.name)
  override val runsBefore: Set[String] = Set(Pickler.name)

  override def allowsImplicitSearch: Boolean = true

  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
      val myPackage: Symbol = requiredPackage("test").moduleClass
      val myImplicit: Symbol = myPackage.requiredClass("Test")

      val ctx2 = ctx.exprContext(tree, tree.symbol).withPhase(this)
      println(ctx2.typer.inferImplicit(myImplicit.namedType, EmptyTree, tree.span)(using ctx2))

      tree

This works if the implicit is defined as a top-level value:

object Test3 {
  given Test = new Test {}
  def test(): Unit = {
    val s: String = ???
    s.length()
  }
}

At the application point s.length() looking up the Test implicit is successful.

However, all other cases fail, e.g.:

object Test4 {
  def test(): Unit = {  
    given Test = new Test {}
    val s: String = ???
    s.length()
  }
}

here, at the application of s.length() no implicit value is found; same if the instance is provided via a using clause of the method declaration, or as a context parameter.

I do realise that probably the "proper" implicit scope is only built out during typer, and for plugins the tree transformations don't re-enrich the scope as the tree is transformed. Though, maybe there is a way to somehow construct the proper implicit search context in my plugin?

Or does this mean that post-typer, there's no way to inject any code that would summon an implicit?