Problematic interaction between `@static` and inline functions with given parameters

[CoolDalek]

Compiler version

3.2.0 and 3.2.1

Minimized code

import java.lang.invoke.{MethodHandles, VarHandle}
import scala.annotation.static
import scala.reflect.{ClassTag, classTag}

class Wrapper(private val underlying: Int)
object Wrapper:
  @static private val vh = Helper.createVH[Wrapper, Int]("underlying")
object Helper:
  inline def createVH[Wrapper: ClassTag, Var: ClassTag](name: String): VarHandle =
    MethodHandles.lookup().findVarHandle(
      classTag[Wrapper].runtimeClass,
      name,
      classTag[Var].runtimeClass,
    )

Output

java.lang.IllegalArgumentException: Could not find proxy for val evidence$1$proxy1: scala.reflect.ClassTag in [value evidence$1$proxy1, value vh, object Wrapper, package <empty>, package <root>], encl = package <empty>, owners = package <empty>, package <root>; enclosures = package <empty>, package <root> while running MegaPhase{lambdaLift, elimStaticThis, countOuterAccesses} on filename.scala

Expectation

Code compiles, the compiler generates static field vh, code from createVH gets inlined into static initializer of the field.

[prolativ]

Minimizing this further:

import scala.annotation.static
import scala.reflect.ClassTag

trait Wrapper
object Wrapper:
  @static val vh = Helper.foo[Wrapper]
object Helper:
  inline def foo[T](using ct: ClassTag[T]) =
    ct.runtimeClass

fails at compile time with a similar error but it starts to compile if we make ct: ClassTag[T] inline:

import scala.annotation.static
import scala.reflect.ClassTag

trait Wrapper
object Wrapper:
  @static val vh = Helper.foo[Wrapper]
object Helper:
  inline def foo[T](using inline ct: ClassTag[T]) =
    ct.runtimeClass

@CoolDalek is this workaround enough for you by the time this gets fixed in the compiler or do you have some more complex cases?

[CoolDalek]

My actual code heavily uses macros, partial application and opaque types and fails even with the workaround.
Minimized version with only partial application works:

class Wrapper(private val underlying: Int)
object Wrapper:
  @static private val vh = Helper[Wrapper](_.underlying)
object Helper:
  class Applicator[Wrapper]:
    inline def apply[Var](getter: Wrapper => Var)
                         (using inline w: ClassTag[Wrapper], inline v: ClassTag[Var]): VarHandle =
      MethodHandles.lookup().findVarHandle(
        classTag[Wrapper].runtimeClass,
        "underlying", // in real code derived via macros from getter
        classTag[Var].runtimeClass,
      )
  end Applicator
  inline def apply[Wrapper]: Applicator[Wrapper] = Applicator[Wrapper]()
end Helper

I can't really make a minimised version with macros and opaque types, but I can provide you with links to the actual code if it helps.

[prolativ]

Links might be useful I you point the places where the workaround doesn't seem to work

[CoolDalek]

Compilation of this file fails: https://github.com/CoolDalek/Flames/blob/queues/src/main/scala/flames/concurrent/execution/atomic/MultiThreaded.scala#L10
(Don't be afraid, all this copy-paste will be gone once Symbol#newClass will be stabilized.)
Here's the partial applicator:
https://github.com/CoolDalek/Flames/blob/queues/src/main/scala/flames/concurrent/execution/handles/VarHandle.scala#L326
The type's declarations are at the very top of the file.
And here is a macro:
https://github.com/CoolDalek/Flames/blob/queues/src/main/scala/flames/concurrent/execution/handles/Macro.scala#L9