Макросы Scala 3: «динамическое» создание экземпляров одноэлементных объектов во время компиляции

Я делал это раньше. Этот подход требует нескольких условий:

• вы должны убедиться, что пользователь действительно пройдет object - вы можете сделать это, например, inline def runFoo[A <: Foo & Singleton]: Unit

• вы НЕ МОЖЕТЕ запретить пользователю делать что-то вроде

  class Example1 {
    def localFunction: Unit = {
      object LocalDefinition extends Foo
      runFoo[LocalDefinition]
    }
  }
  
  class Example2 {
    object LocalDefinition extends Foo
    def localFunction: Unit = {  
      runFoo[LocalDefinition]
    }
  }
  

  и это не может быть реализовано как objects - даже если они являются синглтонами - содержат ссылки на включающие классы. Таким образом, это все равно потребует проверки внутри макроса и ошибки компиляции с сообщением, объясняющим, почему

• в общем, если вы хотите получить доступ к object A extends Foo, в пути к классам должен быть доступен Class[A$], доступный для макроса, поэтому даже такие вещи, как

  object LocalDefinition extends Foo
  runFoo[LocalDefinition]
  

  запрещено, так как вы не можете получить экземпляр чего-то, что еще не выпустило байт-код (а это не так, поскольку файл все еще компилируется, о чем свидетельствует продолжающееся расширение макроса)

Как только мы примем эти ограничения, мы сможем вместе что-нибудь взломать. Я уже создавал прототип чего-то подобного несколько лет назад и использовал результаты в своей OSS-библиотеке, чтобы позволить пользователям настраивать, как должно работать сравнение строк.

Вы начинаете с создания точки входа в макрос:

object Macro:

  inline def runStuff[A <: Foo & Singleton](inline a: A): Unit =
    ${ runStuffImpl[A] }
    
  import scala.quoted.*
  def runStuffImpl[A <: Foo & Singleton: Type](using Quotes): Expr[Unit] =
   ???

Затем мы могли бы реализовать фрагмент кода, который преобразует Symbolимя в Classимя. Я буду использовать упрощенную версию, которая не обрабатывает вложенные объекты:

  def summonModule[M <: Singleton: Type](using Quotes): Option[M] =
    val name: String = TypeRepr.of[M].typeSymbol.companionModule.fullName
    val fixedName = name.replace(raw"$$.", raw"$$") + "$"
    try
      Option(Class.forName(fixedName).getField("MODULE$").get(null).asInstanceOf[M])
    catch
      case _: Throwable => None

с этим мы действительно можем использовать реализацию в макросе (если она доступна):

  def runStuffImpl[A <: Foo & Singleton: Type](using Quotes): Expr[Unit] = {
    import quotes.*
    summonModule[A] match
      case Some(foo) =>
        foo.doStuff()
        '{ () }
      case None =>
        reflect.report.throwError(s"${TypeRepr.of[A].show} cannot be used in macros")
  }

Сделанный.

Тем не менее, этот шаблон класса типов макроса, как я бы его назвал, довольно хрупкий, подвержен ошибкам и неинтуитивен для пользователя, поэтому я бы посоветовал не использовать его, если это возможно, и четко объяснить, какие объекты могут туда помещаться. , как в документации, так и в сообщении об ошибке. Даже тогда это была бы в значительной степени проклятая функция.

Я бы также рекомендовал воздержаться от этого, если вы не можете понять, почему это работает, прочитав код - было бы довольно сложно исправить/редактировать/отладить это, если вы не можете разобраться в путях к классам, загрузчиках классов, предварительном просмотре того, как код Scala преобразуется в байт-код, и т. д.