Trait scala.reflect.api.JavaUniverse

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

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

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

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

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

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

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

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

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

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

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

Пример

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например:

var x = ... fun { x }

Выведет:

Ident(x)

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

Select(Ident(x), "elem")

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

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

Уточнение scala.reflect.api.Mirror для рефлексии во время выполнения с использованием загрузчиков классов JVM.

С этим обновлением зеркала могут преобразовывать артефакты рефлексии Scala (символы и типы) в артефакты рефлексии Java (классы) и наоборот. В результате уточненные зеркала способны выполнять рефлексивные вызовы (получение/установка значений полей, вызов методов и т. д.).

Для получения дополнительной информации о Mirrors см. scala.reflect.api.Mirrors или Руководство по рефлексии: Зеркала

В универсалах рефлексии во время выполнения зеркала являются JavaMirrors.

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

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

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

В вселенных выполнения рефлексии, временное представление класса — это java.lang.Class.

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

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

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

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

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

Зеркало, отражающее поле. Подробная информация о том, как использовать runtime-рефлексию, содержится на странице обзора.

Зеркало, отражающее runtime-значение. Подробная информация о том, как использовать runtime-рефлексию, содержится на странице обзора.

Зеркало, отражающее метод. Подробная информация о том, как использовать runtime-рефлексию, содержится на странице обзора.

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

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

Не имеет специальных методов. Находится здесь для обеспечения стёртой идентичности для 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

Привязка переменной к образцу 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 не указан, 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(cond, thenp, elsep). Этот узел AST соответствует следующему коду Scala:

if (cond) thenp else elsep

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

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

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

Оператор импорта

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. Он используется в основном в качестве метки для проверки того, что импорт был проверен по типу.

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

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

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

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

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

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

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

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

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

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

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

Этот узел AST не имеет прямой корреспонденции с кодом Scala. Он используется для хвостовых вызовов и подобного. Например, while/do десугариваются в метки 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:

значение

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

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

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

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

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

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

селектор match { случаи }

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(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(qual, name). Этот узел AST соответствует Ident, Select или SelectFromTypeTree.

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

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

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

return expr

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

Выбор члена <квалификатор> . <имя>

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

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

qualifier.selector

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

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

Выбор типа <квалификатор> # <имя>, исключенный RefCheck

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

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

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

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

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

C.super[M]

Который представлен как:

Super(This(C), M)

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

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

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

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

Шаблон создания экземпляра класса или тракта

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

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

extends родители { self => тело }

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

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

class C { def foo { // владелец — C def bar // владелец — локальный фиктивный } }

Дерево для термина. Не все деревья, представляющие термины, являются 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.

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

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

try блок catch { обработки_исключений } finally финализатор

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

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

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

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

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

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

Класс-экстрактор для создания и сопоставления с образцом с синтаксисом ValDef(mods, name, tpt, rhs). Этот узел AST соответствует любому из следующих фрагментов кода 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 defs и def defs

A 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")

ConstantTypes обозначают значения, которые могут безопасно быть свёрнуты во время проверки типов. Операция 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, поддерживаемый всеми супертипами. Основной источник информации о типах — страница 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 — возможный пустой список аргументов типа.