Класс scala.reflect.api.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) - представлены непосредственно в виде литералов соответствующего типа; литералы строк - представлены экземплярами String; ссылки на классы, обычно создаваемые с помощью scala.Predef#classOf - представлены как типы; ссылки на значения перечислений - представлены как символы.

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

Ссылки на значения перечислений представлены экземплярами scala.reflect.api.Symbols#Symbol, которые в JVM указывают на методы, возвращающие базовые значения перечислений. Для проверки базового перечисления или получения значения ссылки на перечисление в реальном времени нужно использовать 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 таблицы исходной и целевой вселенных, используя простые строковые имена, программист несет ответственность за то, чтобы убедиться, что импорты не искажают семантику, например, что 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")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Привязка переменной к образцу rhs.

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

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

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

pat*

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

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

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

{ stats; expr }

Если блок пуст, то expr устанавливается в Literal(Constant(())).

Пункт case в сопоставлении с образцом. (за исключением случаев в операторах switch). Удаляется компилятором на этапах patmat (в новом сопоставителе образцов 2.10) или explicitouter (в старом сопоставителе образцов до 2.10)

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

Класс экстрактора для создания и сопоставления с образцом с использованием синтаксиса CaseDef(pat, guard, body). Этот узел AST соответствует следующему коду Scala:

case pat if guard => body

Если guard отсутствует, guard устанавливается в EmptyTree. Если тело не указано, body устанавливается в Literal(Constant(()))

Определение класса.

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

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

mods class name [tparams] impl

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

extends parents { defs }

Пересечение типов <parent1> with ... with <parentN> { <decls> }, удаляется RefCheck

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

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

parent1 with ... with parentN { refinement }

Определение метода или макроса.

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

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

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

Если тип возвращаемого значения не указан явно (т.е. должен быть выведен), это выражается тем, что tpt устанавливается в TypeTree() (но не в EmptyTree!).

Дерево, представляющее сущность, определяющую символ: 1) объявление или определение (тип, класс, объект, пакет, val, var или def) 2) Bind, используемое для представления связывающих вхождений в соответствиях с шаблонами 3) LabelDef, используемое внутри для представления циклов while

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

Узел дерева экзистенциального типа

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

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

tpt forSome { whereClauses }

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

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

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

vparams => body

Символ функции — это синтетический TermSymbol. Это владелец параметров функции.

Общий базовый класс для 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}

Селекторы представляют собой список 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)

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

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

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

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

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

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

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

Разрешены прямые переходы в блоке.

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

Класс-экстрактор для создания и сопоставления с образцом синтаксиса 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 ())

Литерал

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

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

value

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

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

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

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

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

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

selector match { cases }

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

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

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

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

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

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

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

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

mods object name impl

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

extends parents { defs }

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

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

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

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

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

m.f(lhs = rhs)

@annotation(lhs = rhs)

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

API, поддерживаемый всеми операциями создания новых объектов

Класс-экстрактор для создания и сопоставления с образцом синтаксиса 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, поддерживаемый всеми узлами ref

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

Выражение Return

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(elem). Этот узел AST соответствует следующему коду Scala:

pat*

Сверхссылка, где qual — соответствующая ссылка this. Ссылка на супер C.super[M] представлена как Super(This(C), M).

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

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

C.super[M]

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

Super(This(C), M)

Если mix пусто, то это tpnme.EMPTY.

Символ Super — это класс, _из_ которого производится ссылка на супер. Например, в C.super(...), это будет C.

Дерево, содержащее символ, например, определяя его (DefTree) или ссылаясь на него (RefTree). Такие деревья начинаются без символа, возвращая NoSymbol, но после проверки типов без ошибок они содержат непустые символы.

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

Шаблон инициализации класса или тракта

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

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

extends parents { self => body }

В случае отсутствия аннотации self-типа, она представлена как пустое определение с именем nme.WILDCARD и типом NoType.

Символ шаблона — это локальный фиктивный символ. @see Symbol.newLocalDummy Владелец локального фиктивного символа — это окружающий тракт или класс. Локальный фиктивный символ сам является владельцем любых локальных блоков. Например:

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

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

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

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

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 block 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(). Этот узел АСТ не имеет прямого соответствия с кодом Scala и выводится везде, когда требуется обернуть Type в Tree.

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

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

Класс-экстрактор для создания и сопоставления с образцом синтаксиса Typed(expr, tpt). Этот узел АСТ соответствует следующему коду 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, который поддерживают все unapplies

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

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

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

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

Класс-экстрактор для создания и сопоставления с образцом синтаксиса ValDef(mods, name, tpt, rhs). Этот узел АСТ соответствует любому из следующих кодов Scala:

mods val name: tpt = rhs

mods var name: tpt = rhs

mods name: tpt = rhs // в сигнатурах определений функций и методов

self: Bar => // явные типы self

Если тип значения не указан явно (т.е. должен быть выведен), это выражается в том, что tpt установлен в TypeTree() (но не в EmptyTree!).

Общий базовый класс для ValDefs и DefDefs.

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

Тип TypeTag — это scala.reflect.api.TypeTags#WeakTypeTag с дополнительной гарантией, что все ссылки на типы являются конкретными, т.е. он не содержит ссылок на неразрешённые параметры типа или абстрактные типы.

Если требуется неявное значение типа WeakTypeTag[T], компилятор создаст его, а рефлексивное представление T можно получить через поле tpe. Компоненты T могут быть ссылками на параметры типа или абстрактные типы. Обратите внимание, что WeakTypeTag делает всё возможное, чтобы быть как можно более конкретным, т.е. если TypeTag доступны для ссылочных аргументов типа или абстрактных типов, они используются для встраивания конкретных типов в WeakTypeTag. В противном случае WeakTypeTag будет содержать ссылку на абстрактный тип. Это поведение может быть полезным, когда ожидается, что T будет частично абстрактным, но требует особого внимания к этому случаю. Однако, если ожидается, что T будет полностью известен, используйте scala.reflect.api.TypeTags#TypeTag вместо него, что гарантирует это свойство статически.

Для получения дополнительной информации об TypeTag, см. Руководство по рефлексии: TypeTags

Подпись типа AnnotatedType используется для типов с аннотациями вида <type> @<annotation>.

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

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом AnnotatedType(annotations, underlying). Здесь annotations — это аннотации, которые украшают базовый тип underlying. selfSym — это символ, представляющий сам анотированный тип.

BoundedWildcardTypes, используемые только во время вывода типов, создаются в двух местах:

Если ожидаемый тип выражения — это экзистенциальный тип, его скрытые символы заменяются ограниченными универсальными символами. 2. При поиске неявного преобразования, частично основанного на имени метода в преобразуемом типе, создаётся тип HasMethodMatching: MethodType с параметрами, типизированными как BoundedWildcardTypes.

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

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

Подпись типа ClassInfo используется для определения родительских элементов и объявлений классов, трактов и объектов. Если класс, тракт или объект C объявлен так

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

его ClassInfo тип имеет следующий вид:

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

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

Класс-экстрактор для создания и сопоставления с образцом синтаксиса ClassInfo(parents, decls, clazz) Здесь, parents — список родительских типов класса, decls — область, содержащая все объявления в классе, а clazz — символ самого класса.

Подтип Type, представляющий уточнённые типы, а также подписи ClassInfo.

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

Тип ConstantType не может быть выражен в пользовательских программах; он выводится как тип константы. Вот некоторые константы с их типами и внутренним строковым представлением:

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

Типы ConstantType обозначают значения, которые могут безопасно быть сложены во время проверки типов. Операция deconst возвращает эквивалентный тип, который не будет сложен во время проверки.

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

Класс-экстрактор для создания и сопоставления с образцом синтаксиса 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, поддерживаемый всеми типами super. Основным источником информации о типах является страница scala.reflect.api.Types.

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

A singleton type that describes types of the form on the left with the corresponding ThisType representation to the right:

C.this.type             ThisType(C)

The API that all this 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 ThisType(sym) where sym is the class prefix of the this type.

The type of Scala types, and also Scala type signatures. (No difference is internally made between the two).

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

The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types. It is not a first-class type. If an abstract type or type parameter is declared with any of the forms on the left, its type signature is the TypeBounds type on the right.

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

The API that all type bounds 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 TypeBound(lower, upper) Here, lower is the lower bound of the TypeBounds pair, and upper is the upper bound.

The TypeRef type describes types of any of the forms on the left, with their TypeRef representations to the right.

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)

The API that all type refs 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 TypeRef(pre, sym, args) Here, pre is the prefix of the type reference, sym is the symbol referred to by the type reference, and args is a possible empty list of type arguments.

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

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

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

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

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

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

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

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