Класс scala.reflect.macros.Universe

Информация об аннотации.

API экземпляров Annotation. Основной источник информации об аннотациях — страница scala.reflect.api.Annotations.

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Annotation(tpe, scalaArgs, javaArgs). Здесь tpe — тип аннотации, scalaArgs — полезная нагрузка аннотаций Scala, и javaArgs — полезная нагрузка аннотаций Java.

Этот "виртуальный" класс case представляет собой интерфейс отражения для литеральных выражений, которые нельзя далее разложить или оценить, таких как "true", "0", "classOf[List]". Такие значения становятся частями абстрактного синтаксического дерева Scala, представляющего программу. Константы соответствуют разделу 6.24 "Константные выражения" Спецификации языка Scala.

Такие константы используются для представления литералов в абстрактных синтаксических деревьях (узел scala.reflect.api.Trees#Literal) и литеральных аргументов для аннотаций Java-файлов (класс scala.reflect.api.Annotations#LiteralArgument).

К константам можно применять сопоставление с образцом и их можно создавать напрямую, как если бы они были классами case:

assert(Constant(true).value == true)
Constant(true) match {
  case Constant(s: String) =>  println("A string: " + s)
  case Constant(b: Boolean) => println("A boolean value: " + b)
  case Constant(x) =>          println("Something else: " + x)
}

Экземпляры Constant могут оборачивать определённые виды таких выражений:

Литералы примитивных классов значений (Byte, Short, Int, Long, Float, Double, Char, Boolean и Unit) — представлены непосредственно соответствующими литералами typeString — представлены экземплярами String.Ссылки на классы, обычно созданные с помощью scala.Predef#classOf — представлены как типы.Ссылки на значения перечислений — представлены как символы.

Ссылки на классы представлены как экземпляры scala.reflect.api.Types#Type (поскольку при обработке компилятором Scala ссылки на классы подлежащий класс в ходе исполнения ещё может не быть скомпилирован). Чтобы преобразовать такую ссылку в runtime-класс, следует использовать метод runtimeClass зеркала, такого как RuntimeMirror (самый простой способ получить такое зеркало — использовать scala.reflect.runtime.currentMirror).

Ссылки на значения перечислений представлены как экземпляры scala.reflect.api.Symbols#Symbol, которые в JVM указывают на методы, возвращающие лежащие в основе значения перечисления. Чтобы проверить лежащее в основе перечисление или получить runtime-значение ссылки на перечисление, следует использовать scala.reflect.api.Mirrors#RuntimeMirror (самый простой способ получить такое зеркало — снова scala.reflect.runtime.package#currentMirror).

Пример использования:

enum JavaSimpleEnumeration { FOO, BAR }

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface JavaSimpleAnnotation {
  Class<?> classRef();
  JavaSimpleEnumeration enumRef();
}

@JavaSimpleAnnotation(
  classRef = JavaAnnottee.class,
  enumRef = JavaSimpleEnumeration.BAR
)
public class JavaAnnottee {}

import scala.reflect.runtime.universe._
import scala.reflect.runtime.{currentMirror => cm}

object Test extends App {
  val jann = typeOf[JavaAnnottee].typeSymbol.annotations(0).javaArgs
  def jarg(name: String) = jann(TermName(name)) match {
    // Constant is always wrapped into a Literal or LiteralArgument tree node
    case LiteralArgument(ct: Constant) => value
  }

  val classRef = jarg("classRef").value.asInstanceOf[Type]
                                         // ideally one should match instead of casting
  println(showRaw(classRef))             // TypeRef(ThisType(<empty>), JavaAnnottee, List())
  println(cm.runtimeClass(classRef))     // class JavaAnnottee

  val enumRef = jarg("enumRef").value.asInstanceOf[Symbol]
                                         // ideally one should match instead of casting
  println(enumRef)                       // value BAR

  val siblings = enumRef.owner.info.decls
  val enumValues = siblings.filter(sym => sym.isVal && sym.isPublic)
  println(enumValues)                    // Scope{
                                         //   final val FOO: JavaSimpleEnumeration;
                                         //   final val BAR: JavaSimpleEnumeration
                                         // }

  // doesn't work because of https://github.com/scala/bug/issues/6459
  // val enumValue = mirror.reflectField(enumRef.asTerm).get
  val enumClass = cm.runtimeClass(enumRef.owner.asClass)
  val enumValue = enumClass.getDeclaredField(enumRef.name.toString).get(null)
  println(enumValue)                     // BAR
}

API экземпляров Constant.

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Constant(value) где value является значением Scala константы.

Expr оборачивает абстрактное синтаксическое дерево и маркирует его своим типом. Основной источник информации об exprs — страница scala.reflect.api.Exprs.

API объектов FlagSet. Основным источником информации о наборах флагов является страница scala.reflect.api.FlagSets.

Абстрактный тип, представляющий наборы флагов (например, private, final и т. д.), которые применяются к деревьям определений и символам

Все возможные значения, которые могут составлять наборы флагов. Основным источником информации о наборах флагов является страница scala.reflect.api.FlagSets.

Тип свободных терминов, введённых реификацией.

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

$SYMACCESSORS

Тип свободных типов, введённых реификацией.

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

$SYMACCESSORS

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

Рефлексивные артефакты, такие как Символы и Типы, содержатся во вселенных Вселенная. Обычно вся обработка происходит в пределах одной 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, доступными только через приведение типов, что требует глубокого знания компилятора и нарушает гарантии совместимости.

Это привело к созданию модуля internal API для 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 дополнительными функциями, специфичными для вселенной и контекста.

Помечает базовую ссылку на идентификатор как помеченную.

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

API, который поддерживают все ссылки

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

Например:

var x = ... fun { x }

Будет выводить:

Ident(x)

Который преобразуется в:

Select(Ident(x), "elem")

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

Это внутренний класс реализации.

Класс типа, который определяет представление T как Tree.

Класс типа, который определяет способ извлечения экземпляра T из Tree.

Зеркало, отражающее части экземпляра класса времени выполнения. См. страницу обзора для получения подробной информации о том, как использовать отражение времени выполнения.

Зеркало, отражающее поле. См. страницу обзора для получения подробной информации о том, как использовать отражение времени выполнения.

Зеркало, отражающее значение во время выполнения. См. страницу обзора для подробностей о том, как использовать рефлексию во время выполнения.

Зеркало, отражающее метод. См. страницу обзора для подробностей о том, как использовать рефлексию во время выполнения.

Зеркало, отражающее определение Scala-объекта или статические части класса во время выполнения. См. страницу обзора для подробностей о том, как использовать рефлексию во время выполнения.

Зеркало, отражающее экземпляры и статические классы. См. страницу обзора для подробностей о том, как использовать рефлексию во время выполнения.

Не имеет специальных методов. Присутствует для обеспечения стёртой идентичности для RuntimeClass.

API зеркала для рефлексивного мира. См. страницу обзора для подробностей о том, как использовать рефлексию во время выполнения.

Зеркало, отражающее экземпляры или статические части класса во время выполнения. См. страницу обзора для подробностей о том, как использовать рефлексию во время выполнения.

API экземпляров Name.

Не имеет специальных методов. Присутствует для обеспечения стёртой идентичности для TermName.

Класс-экстрактор для создания и сопоставления с образцом синтаксиса TermName(s).

Не имеет специальных методов. Присутствует для обеспечения стёртой идентичности для TypeName.

Класс-экстрактор для создания и сопоставления с образцом синтаксиса TypeName(s).

Неявный класс, который вводит строковые интерполяторы q, tq, cq, pq и fq, которые также известны как квазицитаты. С их помощью вы можете легко манипулировать AST Scala reflection.

Тип области видимости членов, например, в определениях классов.

API, который поддерживают все области видимости членов

Базовый тип всех областей видимости.

API, который поддерживают все области видимости.

Определяет стандартные символы (и типы через его базовый тракт).

Определяет стандартные типы.

Определяет стандартные имена, общие для имен терминов и типов: к ним можно получить доступ через члены nme и tpnme.

Определяет стандартные имена терминов, к которым можно получить доступ через член nme.

Определяет стандартные имена типов, к которым можно получить доступ через член tpnme.

Тип символов классов, представляющих определения классов и признаков.

API символов классов. Основной источник информации о символах — страница Symbols.

Класс Symbol определяет isXXX тестовые методы, такие как isPublic или isFinal, params и returnType методы для символов методов, baseClasses для символов классов и так далее. Некоторые из этих методов не имеют смысла для определенных подклассов Symbol и возвращают NoSymbol, Nil или другие пустые значения.

Тип символов методов, представляющих объявления def.

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

Класс Symbol определяет isXXX тестовые методы, такие как isPublic или isFinal, params и returnType методы для символов методов, baseClasses для символов классов и так далее. Некоторые из этих методов не имеют смысла для определенных подклассов Symbol и возвращают NoSymbol, Nil или другие пустые значения.

Тип символов модулей, представляющих объявления объектов.

API символов модулей. Основной источник информации о символах — страница Symbols.

Класс Symbol определяет isXXX тестовые методы, такие как isPublic или isFinal, params и returnType методы для символов методов, baseClasses для символов классов и так далее. Некоторые из этих методов не имеют смысла для определенных подклассов Symbol и возвращают NoSymbol, Nil или другие пустые значения.

Тип символов, представляющих объявления.

API символов. Основной источник информации о символах — страница Symbols.

Класс Symbol определяет isXXX тестовые методы, такие как isPublic или isFinal, params и returnType методы для символов методов, baseClasses для символов классов и так далее. Некоторые из этих методов не имеют смысла для определенных подклассов Symbol и возвращают NoSymbol, Nil или другие пустые значения.

Тип символов термов, представляющих объявления val, var, def и object, а также пакеты и параметры значений.

API символов терминалов. Основной источник информации о символах — страница Symbols.

Класс Symbol определяет isXXX тестовые методы, такие как isPublic или isFinal, params и returnType методы для символов методов, baseClasses для символов классов и так далее. Некоторые из этих методов не имеют смысла для определенных подклассов Symbol и возвращают NoSymbol, Nil или другие пустые значения.

Тип символов типов, представляющих объявления типов, классов и признаков, а также параметры типов.

API символов типов. Основной источник информации о символах — страница Symbols.

Класс Symbol определяет isXXX тестовые методы, такие как isPublic или isFinal, params и returnType методы для символов методов, baseClasses для символов классов и так далее. Некоторые из этих методов не имеют смысла для определенных подклассов Symbol и возвращают NoSymbol, Nil или другие пустые значения.

Альтернативы шаблонов.

Исключаются фазами компилятора Исключаются фазами компилятора patmat (в новом механизме сопоставления шаблонов 2.10) или explicitouter (в старом механизме сопоставления шаблонов до 2.10), за исключением вхождений в закодированном операторе Switch (т.е. оставшийся Match(CaseDef(...)))

API, который поддерживают все альтернативы

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом Alternative(trees). Этот узел AST соответствует следующему коду Scala:

pat1 | ... | patn

Узел дерева с прикрепленным к нему аннотацией. Используется только для аннотированных типов и атрибутов аннотаций, аннотации в определениях хранятся в Modifiers. Удаляется типечекером (typedAnnotated), аннотации затем хранятся в AnnotatedType.

API, который поддерживают все аннотированные элементы

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом Annotated(annot, arg). Этот узел AST соответствует следующему коду Scala:

arg @annot // для типов arg: @annot // для выражений

Применяемый тип <tpt> [ <args> ], исключается RefCheck

API, который поддерживают все применённые деревья типов

Класс-экстрактор для создания и сопоставления с шаблоном синтаксиса AppliedTypeTree(tpt, args). Этот узел AST соответствует следующему коду Scala:

tpt[args]

Следует использовать только с tpt узлами, которые являются типами, т.е. у которых isType возвращает true. В противном случае следует использовать TypeApply.

List[Int] как в val x: List[Int] = ??? // представлено как AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))

def foo[T] = ??? foo[Int] // представлено как TypeApply(Ident(<foo>), List(TypeTree(<Int>)))

Применение значения

API, который поддерживают все применения

Класс-экстрактор для создания и сопоставления с шаблоном синтаксиса Apply(fun, args). Этот узел AST соответствует следующему коду Scala:

fun(args)

Например:

fun[targs](args)

Выражается как:

Apply(TypeApply(fun, targs), args)

Присваивание

API, который поддерживают все присваивания

Класс-экстрактор для создания и сопоставления с шаблоном синтаксиса Assign(lhs, rhs). Этот узел AST соответствует следующему коду Scala:

lhs = rhs

Связывание переменной с правой частью шаблона.

Устранён фазами компилятора patmat (в новом поиске шаблонов 2.10) или explicitouter (в старом поиске шаблонов до 2.10).

API, который поддерживают все связывания

Класс-экстрактор для создания и сопоставления с шаблоном синтаксиса Bind(name, body). Этот узел AST соответствует следующему коду Scala:

pat*

Блок выражений (выражения, разделённые точкой с запятой).

API, который поддерживают все блоки

An extractor class to create and pattern match with syntax Block(stats, expr). This AST node corresponds to the following Scala code:

{ stats; expr }

If the block is empty, the expr is set to Literal(Constant(())).

Case clause in a pattern match. (except for occurrences in switch statements). Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher)

The API that all case defs support

An extractor class to create and pattern match with syntax CaseDef(pat, guard, body). This AST node corresponds to the following Scala code:

case pat if guard => body

If the guard is not present, the guard is set to EmptyTree. If the body is not specified, the body is set to Literal(Constant(()))

A class definition.

The API that all class defs support

An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl). This AST node corresponds to the following Scala code:

mods class name [tparams] impl

Where impl stands for:

extends parents { defs }

Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck

The API that all compound type trees support

An extractor class to create and pattern match with syntax CompoundTypeTree(templ). This AST node corresponds to the following Scala code:

parent1 with ... with parentN { refinement }

A method or macro definition.

The API that all def defs support

An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs). This AST node corresponds to the following Scala code:

mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs

If the return type is not specified explicitly (i.e. is meant to be inferred), this is expressed by having tpt set to TypeTree() (but not to an EmptyTree!).

A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2) Связь, используемая для представления связывающих вхождений в сопоставления с образцом 3) МеткаDef, используемая во внутренних целях для представления циклов while

API, поддерживаемый всеми деревьями def

Узел дерева сущностного типа

API, поддерживаемый всеми деревьями сущностных типов

An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses). This AST node corresponds to the following Scala code:

tpt forSome { whereClauses }

Анонимная функция, исключённая фазой компилятора lambdalift

API, поддерживаемый всеми функциями

An extractor class to create and pattern match with syntax Function(vparams, body). This AST node corresponds to the following Scala code:

vparams => body

The symbol of a Function is a synthetic TermSymbol. It is the owner of the function's parameters.

Общие базовые классы для Apply и TypeApply.

API, поддерживаемый всеми операциями применения

Ссылка на идентификатор name.

API, который поддерживают все идентификаторы

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом Ident(qual, name). Этот узел AST соответствует следующему коду Scala:

name

Проверка типов преобразует идентификаторы, которые ссылаются на поля или методы, окружающие их, в селекторы. Например, name ==> this.name

Условное выражение

API, который поддерживают все операторы if

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом If(cond, thenp, elsep). Этот узел AST соответствует следующему коду Scala:

if (cond) thenp else elsep

Если альтернатива отсутствует, то elsep устанавливается в Literal(Constant(())).

Базовый класс для определений классов и объектов.

API, который поддерживают все определения impl

Пункт импорта

API, который поддерживают все операторы импорта

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом Import(expr, selectors). Этот узел AST соответствует следующему коду Scala:

import expr.{selectors}

Selectors - это список ImportSelectors, которые концептуально представляют собой пары имен (from, to). Последнее (и, возможно, единственное) имя может быть nme.WILDCARD. Например:

import qual.{w => _, x, y => z, _}

Будет представлено как:

Import(qual, List(("w", WILDCARD), ("x", "x"), ("y", "z"), (WILDCARD, null)))

Символ Import - это импортируемый символ @see Symbol.newImport. Он используется в основном как маркер для проверки того, что импорт прошел проверку типов.

Селектор импорта (не дерево, а компонент дерева Import)

Представление импортируемого имени, его необязательного переименования и их необязательных позиций

Удаляется проверкой типов.

Интерфейс, поддерживаемый всеми селекторами импорта

Класс-экстрактор для создания и сопоставления с образцом синтаксиса ImportSelector(name, namePos, rename, renamePos). Это не узел AST, он используется как часть узла Import.

Выражение с меткой. Не выражается в синтаксисе языка, но генерируется компилятором для имитации циклов while/do-while, а также соответствием шаблонов.

Метка действует как вложенная функция, где params представляет входные параметры. Символ, заданный для LabelDef, должен иметь тип MethodType, как если бы это была вложенная функция.

Переходы — это узлы apply, связанные с символом метки. Аргументы из узла apply будут переданы метке и присвоены Idents.

Внутри блока разрешены переходы вперед.

Интерфейс, поддерживаемый всеми определениями меток

Класс-экстрактор для создания и сопоставления с образцом синтаксиса LabelDef(name, params, rhs).

Этот узел AST не имеет прямого соответствия в коде Scala. Он используется для хвостовых вызовов и подобных. Например, while/do десугариваются до label def следующим образом:

while (cond) body ==> LabelDef($L, List(), if (cond) { body; L$() } else ())

do body while (cond) ==> LabelDef($L, List(), body; if (cond) L$() else ())

Литерал

Интерфейс, поддерживаемый всеми литералами

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Literal(value). Этот узел AST соответствует следующему коду Scala:

value

- Выражение сопоставления с образцом (до фазы компилятора explicitouter до 2.10 / patmat с 2.10)

Условные операторы (после фазы компилятора explicitouter до 2.10 / patmat с 2.10)

После фазы компилятора explicitouter до 2.10 / patmat с 2.10, случаи будут удовлетворять следующим ограничениям:

все условия — EmptyTree,все шаблоны будут либо Literal(Constant(x:Int)), либо Alternative(lit|...|lit), за исключением ветви «иначе», у которой шаблон Ident(nme.WILDCARD)

Интерфейс, поддерживаемый всеми операторами сопоставления

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Match(selector, cases). Этот узел AST соответствует следующему коду Scala:

selector match { cases }

Match также используется в операторах присваивания сопоставления с образцом, например, val (foo, bar) = baz.

Общий базовый класс для всех определений членов: типы, классы, объекты, пакеты, vals и vars, defs.

API, поддерживаемый всеми определениями членов

API, поддерживаемый всеми модификаторами

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Modifiers(flags, privateWithin, annotations). Модификаторы объединяют флаги, аннотации видимости и аннотации Scala для определений членов.

Определение объекта, например, object Foo. Внутренне объекты часто называют модулями для уменьшения неоднозначности. Удалено фазой компилятора refcheck.

API, поддерживаемый всеми определениями модулей

Класс-экстрактор для создания и сопоставления с образцом синтаксиса ModuleDef(mods, name, impl). Этот узел AST соответствует следующему коду Scala:

mods object name impl

Где impl обозначает:

extends parents { defs }

Дерево, содержащее имя, например, путем его определения (DefTree) или ссылки на него (RefTree).

API, поддерживаемый всеми деревьями имен

Присваивание или именованный аргумент. Появляется только в списках аргументов, удаляется фазой компилятора typecheck (doTypedApply), возрождается реификером.

API, поддерживаемый всеми присваиваниями

Класс-экстрактор для создания и сопоставления с образцом синтаксиса NamedArg(lhs, rhs). Этот узел AST соответствует следующему коду Scala:

m.f(lhs = rhs)

@annotation(lhs = rhs)

Создание объекта

API, поддерживаемый всеми объектами New

Класс-извлекатель для создания и сопоставления шаблонов с синтаксисом New(tpt). Этот узел AST соответствует следующему коду Scala:

new T

Этот узел всегда встречается в следующем контексте:

(new tpt).<init>[targs](args)

Например, AST-представление:

new Example[Int](2)(3)

выглядит следующим образом:

Apply( Apply( TypeApply( Select(New(TypeTree(typeOf[Example])), nme.CONSTRUCTOR) TypeTree(typeOf[Int])), List(Literal(Constant(2)))), List(Literal(Constant(3))))

Пакет, например package pid { stats }

API, поддерживаемый всеми определениями пакетов

Класс-извлекатель для создания и сопоставления шаблонов с синтаксисом PackageDef(pid, stats). Этот узел AST соответствует следующему коду Scala:

package pid { stats }

Узел, ссылающийся на сущность, содержащую символ. Ссылается на одну сущность, в отличие от определения; определения находятся в DefTrees.

API, поддерживаемый всеми узлами RefTree

Класс-извлекатель для создания и сопоставления шаблонов с синтаксисом RefTree(qual, name). Этот узел AST соответствует либо Ident, Select, либо SelectFromTypeTree.

Выражение возврата

API, поддерживаемый всеми операторами возврата

Класс-извлекатель для создания и сопоставления шаблонов с синтаксисом Return(expr). Этот узел AST соответствует следующему коду Scala:

return expr

Символ узла Return — это окружающий метод.

Выбор члена <qualifier> . <name>

API, который поддерживают все Select

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом Select(qual, name). Этот узел AST соответствует следующему коду Scala:

qualifier.selector

Следует использовать только с узлами qualifier, которые являются терминами, т.е. которые имеют isTerm, возвращающий true. В противном случае следует использовать SelectFromTypeTree.

foo.Bar // представлен как Select(Ident(<foo>), <Bar>) Foo#Bar // представлен как SelectFromTypeTree(Ident(<Foo>), <Bar>)

Выбор типа <qualifier> # <name>, исключён RefCheck

API, который поддерживают все Select из деревьев типов

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом SelectFromTypeTree(qualifier, name). Этот узел AST соответствует следующему коду Scala:

qualifier # selector

Примечание: зависимый от пути тип p.T выражается как p.type # T

Следует использовать только с узлами qualifier, которые являются типами, т.е. которые имеют isType, возвращающий true. В противном случае следует использовать Select.

Foo#Bar // представлен как SelectFromTypeTree(Ident(<Foo>), <Bar>) foo.Bar // представлен как Select(Ident(<foo>), <Bar>)

Синглтонный тип, исключён RefCheck

API, который поддерживают все синглтонные деревья типов

Класс экстрактора для создания и сопоставления шаблонов с синтаксисом SingletonTypeTree(ref). Этот узел AST соответствует следующему коду Scala:

ref.type

Повторение шаблона.

Исключается компилятором на этапах patmat (в новом механизме сопоставления шаблонов 2.10) или explicitouter (в старом механизме сопоставления шаблонов до 2.10).

API, который поддерживают все Star

An extractor class to create and pattern match with syntax Star(elem). This AST node corresponds to the following Scala code:

pat*

Super reference, where qual is the corresponding this reference. A super reference C.super[M] is represented as Super(This(C), M).

The API that all supers support

An extractor class to create and pattern match with syntax Super(qual, mix). This AST node corresponds to the following Scala code:

C.super[M]

Which is represented as:

Super(This(C), M)

If mix is empty, it is tpnme.EMPTY.

The symbol of a Super is the class _from_ which the super reference is made. For instance in C.super(...), it would be C.

A tree that carries a symbol, e.g. by defining it (DefTree) or by referring to it (RefTree). Such trees start their life naked, returning NoSymbol, but after being typechecked without errors they hold non-empty symbols.

The API that all sym trees support

Instantiation template of a class or trait

The API that all templates support

An extractor class to create and pattern match with syntax Template(parents, self, body). This AST node corresponds to the following Scala code:

extends parents { self => body }

In case when the self-type annotation is missing, it is represented as an empty value definition with nme.WILDCARD as name and NoType as type.

The symbol of a template is a local dummy. @see Symbol.newLocalDummy The owner of the local dummy is the enclosing trait or class. The local dummy is itself the owner of any local blocks. For example:

class C { def foo { // owner is C def bar // owner is local dummy } }

A tree for a term. Not all trees representing terms are TermTrees; use isTerm to reliably identify terms.

The API that all term trees support

Ссылка на себя

API, который поддерживают все this

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом This(qual). Этот узел AST соответствует следующему коду Scala:

qual.this

Символ This — это класс, к которому относится this. Например, в C.this это будет C.

Выражение Throw

API, который поддерживают все попытки

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом Throw(expr). Этот узел AST соответствует следующему коду Scala:

throw expr

Класс, реализующий стандартную стратегию преобразования дерева: клонирование покомпонентно в ширину.

Класс, реализующий стандартную стратегию обхода дерева: покомпонентно в ширину.

Тип деревьев абстрактной синтаксической структуры Scala.

API, который поддерживают все деревья. Основным источником информации о деревьях является страница scala.reflect.api.Trees.

Тип стандартных (ленивых) копиров деревьев.

API копира дерева.

Узел Try catch.

API, который поддерживают все попытки

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Try(block, catches, finalizer). Этот узел AST соответствует следующему коду Scala:

try блок catch { catches } finally finalizer

Если finalizer отсутствует, то finalizer устанавливается в значение EmptyTree.

Дерево для типа. Не все деревья, представляющие типы, являются TypTrees; используйте isType для надежной идентификации типов.

API, поддерживаемый всеми деревьями типов

Явное применение типа.

API, поддерживаемый всеми применениями типов

Класс-экстрактор для создания и сопоставления с образцом синтаксиса TypeApply(fun, args). Этот узел AST соответствует следующему коду Scala:

fun[args]

Должен использоваться только с узлами fun, которые являются терминами, т.е. имеющими isTerm, возвращающими true. В противном случае следует использовать AppliedTypeTree.

def foo[T] = ??? foo[Int] // представлено как TypeApply(Ident(<foo>), List(TypeTree(<Int>)))

List[Int] как в val x: List[Int] = ??? // представлено как AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))

Узел дерева границ типов

API, поддерживаемый всеми деревьями границ типов

Класс-экстрактор для создания и сопоставления с образцом синтаксиса TypeBoundsTree(lo, hi). Этот узел AST соответствует следующему коду Scala:

>: lo <: hi

Абстрактный тип, параметр типа или псевдоним типа. Устраняется стиранием.

API, поддерживаемый всеми определениями типов

Класс-экстрактор для создания и сопоставления шаблонов с синтаксисом TypeDef(mods, name, tparams, rhs). Этот узел AST соответствует следующему коду Scala:

mods type name[tparams] = rhs

mods type name[tparams] >: lo <: hi

Первый пример использования демонстрирует TypeDefs, представляющие псевдонимы типов и параметры типов. Второй пример демонстрирует TypeDefs, представляющие абстрактные типы, где lo и hi оба являются TypeBoundsTrees, и Modifier.deferred установлено в mods.

Синтетическое дерево, содержащее произвольный тип. Не следует путать с TypTree, который является трейтом для деревьев, используемых только для деревьев типов. TypeTree вставляются в нескольких местах, но, прежде всего, в RefCheck, где все произвольные деревья типов заменяются TypeTree.

API, поддерживаемый всеми деревьями типов.

Класс-экстрактор для создания и сопоставления шаблонов с синтаксисом TypeTree(). Этот узел AST не имеет прямого соответствия коду Scala и генерируется повсюду, когда требуется обернуть Type в Tree.

Аннотация типа, удалённая на этапе очистки компилятора.

API, поддерживаемый всеми типами.

Класс-экстрактор для создания и сопоставления шаблонов с синтаксисом Typed(expr, tpt). Этот узел AST соответствует следующему коду Scala:

expr: tpt

Используется для представления методов unapply в сопоставлении шаблонов.

Например:

2 match { case Foo(x) => x }

Представляется как:

Match(
  Literal(Constant(2)),
  List(
    CaseDef(
      UnApply(
        // a dummy node that carries the type of unapplication to patmat
        // the <unapply-selector> here doesn't have an underlying symbol
        // it only has a type assigned, therefore after `untypecheck` this tree is no longer typeable
        Apply(Select(Ident(Foo), TermName("unapply")), List(Ident(TermName("<unapply-selector>")))),
        // arguments of the unapply => nothing synthetic here
        List(Bind(TermName("x"), Ident(nme.WILDCARD)))),
      EmptyTree,
      Ident(TermName("x")))))

Введен типом typer. Удаляется на этапах компиляции patmat (в новом сопоставлении шаблонов 2.10) или explicitouter (в старом сопоставлении шаблонов до 2.10).

API, поддерживаемый всеми unapply.

Класс-экстрактор для создания и сопоставления шаблонов с синтаксисом UnApply(fun, args). Этот узел AST не имеет прямого соответствия коду Scala и вводится при проверке типов для сопоставления шаблонов и try блоков.

В широком смысле, определение значения. Всё это закодировано как ValDefs:

неизменяемые значения, например, "val x"изменяемые значения, например, "var x" - флаг MUTABLE установлен в modsленивые значения, например, "lazy val x" - флаг LAZY установлен в modsпараметры метода, см. vparamss в scala.reflect.api.Trees#DefDef - флаг PARAM установлен в modsявные типы "self", например, class A { self: Bar => }

API, который поддерживают все val def

An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs). This AST node corresponds to any of the following Scala code:

mods val name: tpt = rhs

mods var name: tpt = rhs

mods name: tpt = rhs // in signatures of function and method definitions

self: Bar => // self-types

If the type of a value is not specified explicitly (i.e. is meant to be inferred), this is expressed by having tpt set to TypeTree() (but not to an EmptyTree!).

A common base class for ValDefs and DefDefs.

The API that all val defs and def defs support

A TypeTag is a scala.reflect.api.TypeTags#WeakTypeTag with the additional static guarantee that all type references are concrete, i.e. it does not contain any references to unresolved type parameters or abstract types.

If an implicit value of type WeakTypeTag[T] is required, the compiler will create one, and the reflective representation of T can be accessed via the tpe field. Components of T can be references to type parameters or abstract types. Note that WeakTypeTag makes an effort to be as concrete as possible, i.e. if TypeTags are available for the referenced type arguments or abstract types, they are used to embed the concrete types into the WeakTypeTag. Otherwise the WeakTypeTag will contain a reference to an abstract type. This behavior can be useful, when one expects T to be perhaps be partially abstract, but requires special care to handle this case. However, if T is expected to be fully known, use scala.reflect.api.TypeTags#TypeTag instead, which statically guarantees this property.

For more information about TypeTags, see the Reflection Guide: TypeTags

The AnnotatedType type signature is used for annotated types of the for <type> @<annotation>.

The API that all annotated types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying). Here, annotations are the annotations decorating the underlying type underlying. selfSym is a symbol representing the annotated type itself.

BoundedWildcardTypes, used only during type inference, are created in two places:

If the expected type of an expression is an existential type, its hidden symbols are replaced with bounded wildcards. 2. When an implicit conversion is being sought based in part on the name of a method in the converted type, a HasMethodMatching type is created: a MethodType with parameters typed as BoundedWildcardTypes.

The API that all these types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax BoundedWildcardTypeExtractor(bounds) with bounds denoting the type bounds.

The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects. If a class, trait, or object C is declared like this

C extends P_1 with ... with P_m { D_1; ...; D_n}

its ClassInfo type has the following form:

ClassInfo(List(P_1, ..., P_m), Scope(D_1, ..., D_n), C)

The API that all class info types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax ClassInfo(parents, decls, clazz) Here, parents is the list of parent types of the class, decls is the scope containing all declarations in the class, and clazz is the symbol of the class itself.

A subtype of Type representing refined types as well as ClassInfo signatures.

Has no special methods. Is here to provide erased identity for CompoundType.

A ConstantType type cannot be expressed in user programs; it is inferred as the type of a constant. Here are some constants with their types and the internal string representation:

1           ConstantType(Constant(1))       Int(1)
"abc"       ConstantType(Constant("abc"))   String("abc")

ConstantTypes denote values that may safely be constant folded during type checking. The constantFold operation returns the equivalent type that will not be constant folded.

The API that all constant types support. The main source of information about types is the scala.reflect.api.Types page.

Класс экстрактора для создания и сопоставления с образцом с помощью синтаксиса ConstantType(constant) Здесь, constant - это константное значение, представленное типом.

Подпись типа ExistentialType используется для экзистенциальных типов и типов с подстановкой.

API, который поддерживают все экзистенциальные типы. Основной источник информации о типах - страница scala.reflect.api.Types.

Класс экстрактора для создания и сопоставления с образцом с помощью синтаксиса ExistentialType(quantified, underlying). Здесь, quantified - это переменные типа, связанные экзистенциальным типом, и underlying - это тип, который экзистенциально квантифицирован.

Подпись типа MethodType используется для указания параметров и типа результата метода

API, который поддерживают все типы методов. Основной источник информации о типах - страница scala.reflect.api.Types.

Класс экстрактора для создания и сопоставления с образцом с помощью синтаксиса MethodType(params, restpe) Здесь, params - это потенциально пустой список символов параметров метода, а restpe - это тип результата метода. Если метод каррирован, restpe будет другим MethodType. Примечание: MethodType(Nil, Int) будет типом метода, определенного с пустым списком параметров.

def f(): Int

Если метод полностью без параметров, как в

def f: Int

его тип является NullaryMethodType.

Подпись типа NullaryMethodType используется для методов без параметров с объявлениями формы def foo: T

API, который поддерживают все типы методов без параметров. Основной источник информации о типах - страница scala.reflect.api.Types.

Класс экстрактора для создания и сопоставления с образцом с помощью синтаксиса NullaryMethodType(resultType). Здесь, resultType - это тип результата метода без параметров.

Подпись типа PolyType используется для полиморфных методов, имеющих хотя бы один параметр типа.

API, поддерживаемый всеми полиморфными типами. Основной источник информации о типах — страница scala.reflect.api.Types.

Экстракторный класс для создания и сопоставления с образцом с помощью синтаксиса PolyType(typeParams, resultType). Здесь typeParams — параметры типа метода, а resultType — сигнатура типа после параметров типа.

Тип RefinedType определяет типы любой из форм слева, с их представлениями RefinedType справа.

P_1 with ... with P_m { D_1; ...; D_n}      RefinedType(List(P_1, ..., P_m), Scope(D_1, ..., D_n))
P_1 with ... with P_m                       RefinedType(List(P_1, ..., P_m), Scope())
{ D_1; ...; D_n}                            RefinedType(List(AnyRef), Scope(D_1, ..., D_n))

API, поддерживаемый всеми уточнёнными типами. Основной источник информации о типах — страница scala.reflect.api.Types.

Экстракторный класс для создания и сопоставления с образцом с помощью синтаксиса RefinedType(parents, decls). Здесь parents — список родительских типов класса, а decls — область видимости, содержащая все объявления в классе.

Тип SingleType описывает типы любой из форм слева, с их представлениями TypeRef справа.

(T # x).type             SingleType(T, x)
p.x.type                 SingleType(p.type, x)
x.type                   SingleType(NoPrefix, x)

API, поддерживаемый всеми одиночными типами. Основной источник информации о типах — страница scala.reflect.api.Types.

Экстракторный класс для создания и сопоставления с образцом с помощью синтаксиса SingleType(pre, sym). Здесь pre — префикс одиночного типа, а sym — символ стабильного значения, на который ссылается одиночный тип.

Тип одиночных типов Scala, то есть типов, которые содержат только одно ненулевое значение. К ним относятся типы форм

C.this.type
C.super.type
x.type

а также типы констант.

Не имеет специальных методов. Находится здесь для обеспечения стёртой идентичности для SingletonType.

Тип SuperType не записывается непосредственно, а возникает, когда C.super используется в качестве префикса в TypeRef или SingleType. Его внутреннее представление

SuperType(thistpe, supertpe)

Здесь, thistpe — тип соответствующего типа this. Например, в типе, возникающем из C.super, часть thistpe будет ThisType(C). supertpe — тип суперкласса, на который ссылается super.

API, поддерживаемый всеми супертипами. Основным источником информации о типах является страница scala.reflect.api.Types.

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом SuperType(thistpe, supertpe)

Тип-синглтон, описывающий типы в левой части с соответствующим представлением ThisType в правой части:

C.this.type             ThisType(C)

API, поддерживаемый всеми типами this. Основным источником информации о типах является страница scala.reflect.api.Types.

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом ThisType(sym), где sym — префикс класса типа this.

Тип Scala-типов, а также сигнатур типов Scala. (Внутри между ними нет различий).

API типов. Основным источником информации о типах является страница scala.reflect.api.Types.

Подпись типа TypeBounds используется для указания нижних и верхних границ типов параметров и абстрактных типов. Это не тип первого класса. Если абстрактный тип или параметр типа объявлен с любым из форм слева, его подпись — тип TypeBounds справа.

T >: L <: U               TypeBounds(L, U)
T >: L                    TypeBounds(L, Any)
T <: U                    TypeBounds(Nothing, U)

API, поддерживаемый всеми границами типов. Основным источником информации о типах является страница scala.reflect.api.Types.

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом TypeBound(lower, upper). Здесь lower — нижняя граница пары TypeBounds, а upper — верхняя граница.

Тип TypeRef описывает типы любого из представленных слева форм, с их представлениями TypeRef справа.

T # C[T_1, ..., T_n]      TypeRef(T, C, List(T_1, ..., T_n))
p.C[T_1, ..., T_n]        TypeRef(p.type, C, List(T_1, ..., T_n))
C[T_1, ..., T_n]          TypeRef(NoPrefix, C, List(T_1, ..., T_n))
T # C                     TypeRef(T, C, Nil)
p.C                       TypeRef(p.type, C, Nil)
C                         TypeRef(NoPrefix, C, Nil)

API, поддерживаемый всеми ссылками на типы. Основным источником информации о типах является страница scala.reflect.api.Types.

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом TypeRef(pre, sym, args) Здесь pre — префикс ссылки на тип, sym — символ, на который ссылается ссылка на тип, а args — возможный пустой список аргументов типа.

Базовый тип всех зеркал этого вселенной.

Этот абстрактный тип соответствует базовому интерфейсу для всех зеркал, определенных в scala.reflect.api.Mirror, и постепенно уточняется в конкретных вселенных (например, Mirror scala.reflect.api.JavaUniverse обладает возможностью рефлексии).

Тип модификаторов дерева (не само дерево, а скорее часть DefTrees).

Абстрактный тип имен.

Определяет понятие позиций, специфичное для вселенной. Основная документация по позициям находится по адресу scala.reflect.api.Position.

Абстрагирует представление класса во время выполнения на платформе.

Абстрактный тип имен, представляющих типы.

Абстрактный тип имен, представляющих термины.