Трейт scala.reflect.api.Internals

API свободных символов терминов. Основным источником информации о символах является страница Symbols.

$SYMACCESSORS

API свободных символов типов. Основным источником информации о символах является страница Symbols.

$SYMACCESSORS

Этот тракт обеспечивает поддержку импортёров, механизма миграции артефактов рефлексии между вселенными. Примечание: этот тракт обычно следует использовать только в редких случаях.

Артефакты рефлексии, такие как Symbols и Types, содержатся во вселенных Universe. Обычно вся обработка происходит в пределах одной Universe (например, макроса времени компиляции Universe или рефлексии во время выполнения Universe), но иногда требуется мигрировать артефакты из одной Universe в другую. Например, компиляция во время выполнения работает путём импорта деревьев рефлексии времени выполнения в вселенную компилятора времени выполнения, компиляции импортируемых элементов и экспорта результата обратно.

Артефакты рефлексии прочно связаны со своими Universe , что отражается тем, что типы артефактов из разных вселенных несовместимы. Однако, используя Importer, их можно импортировать из одной вселенной в другую. Например, для импорта foo.bar.Baz из исходной Universe в целевую Universe, импортёр сначала проверит, существует ли вся цепочка владельца в целевой Universe. Если она есть, то ничего больше не будет сделано. В противном случае импортёр воссоздаст всю цепочку владельца и импортирует соответствующие подписи типов в целевую Universe.

Поскольку импортёры сопоставляют Symbol таблицы источника и целевых Universe используя простые строковые имена, программист отвечает за то, чтобы убедиться, что импорты не искажают семантику, например, что foo.bar.Baz в исходной Universe означает то же, что и foo.bar.Baz в целевой Universe.

Пример

Вот как можно реализовать макрос, который выполняет вычисление своего аргумента во время компиляции, используя компилятор во время выполнения для компиляции и оценки дерева, принадлежащего компилятору во время компиляции:

def staticEval[T](x: T) = macro staticEval[T]

def staticEval[T](c: scala.reflect.macros.blackbox.Context)(x: c.Expr[T]) = {
  // creates a runtime reflection universe to host runtime compilation
  import scala.reflect.runtime.{universe => ru}
  val mirror = ru.runtimeMirror(c.libraryClassLoader)
  import scala.tools.reflect.ToolBox
  val toolBox = mirror.mkToolBox()

  // runtime reflection universe and compile-time macro universe are different
  // therefore an importer is needed to bridge them
  // currently mkImporter requires a cast to correctly assign the path-dependent types
  val importer0 = ru.internal.mkImporter(c.universe)
  val importer = importer0.asInstanceOf[ru.internal.Importer { val from: c.universe.type }]

  // the created importer is used to turn a compiler tree into a runtime compiler tree
  // both compilers use the same classpath, so semantics remains intact
  val imported = importer.importTree(tree)

  // after the tree is imported, it can be evaluated as usual
  val tree = toolBox.untypecheck(imported.duplicate)
  val valueOfX = toolBox.eval(imported).asInstanceOf[T]
  ...
}

API рефлексии демонстрирует противоречие, свойственное экспериментальным вещам: с одной стороны, мы хотим, чтобы он вырос в красивую и надёжную API, а с другой стороны, мы должны справляться с незрелостью лежащих в основе механизмов, предоставляя не очень привлекательные решения для включения важных вариантов использования.

В Scala 2.10, что было нашей первой попыткой API рефлексии, у нас не было систематического подхода к решению этого противоречия, иногда делая слишком много видимым из внутренних механизмов (например, Symbol.deSkolemize) и иногда слишком мало (например, до сих пор нет механизма изменения владельцев, выполнения преобразований типизации и т. д.). Это привело к определённой путанице с некоторыми внутренними API, живущими среди публичных, пугая новичков, и некоторыми внутренними API, доступными только через приведение типов, что требует глубокого знания компилятора и нарушает гарантии совместимости.

Это привело к созданию модуля API internal для API рефлексии, который предоставляет расширенные API, необходимые для макросов, которые продвигают границы современного состояния, чётко отделяя их от более или менее прямолинейного остатка и предоставляя гарантии совместимости наравне с остальной частью API рефлексии (полная совместимость в рамках мелких релизов, лучшие усилия по обратной совместимости в рамках основных релизов, ясный путь замены в случае редких несовместимых изменений в основных релизах).

Сам модуль internal (значение, реализующее InternalApi) не определён здесь, в scala.reflect.api.Universe, а предоставляется на основе реализации. Точка входа API во время выполнения (scala.reflect.runtime.universe) предоставляет universe.compat: InternalApi, в то время как точки входа API во время компиляции (экземпляры scala.reflect.macros.Context) предоставляют c.compat: ContextInternalApi, который расширяет InternalApi дополнительной функциональностью, специфичной для вселенной и контекста.

Помечает лежащий в основе reference к id как упакованный.

Предварительное условие: id должен ссылаться на захваченную переменную. Reference, помеченная таким образом, будет ссылаться на упакованный объект, никакое разыменование с `.elem` не выполняется на нём. Этот узел дерева может быть выпущен макросами, такими как reify, которые вызывают referenceCapturedVariable. Он удаляется в LambdaLift, где происходит преобразование упаковывания.

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом ReferenceToBoxed(ident). Этот узел AST не имеет прямого соответствия коду Scala и генерируется макросами для прямого обращения к переменным захвата, минуя elem.

Например:

var x = ... fun { x }

Сгенерирует:

Ident(x)

Что преобразуется в:

Select(Ident(x), "elem")

Если вместо Ident использовался бы ReferenceToBoxed, преобразование не производилось бы.