Universe

Type Members

1. abstract type Alternative >: Null <: Universe.AlternativeApi with Universe.TermTree

   

   Alternatives of patterns.

   Alternatives of patterns.

   Eliminated by compiler phases Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher), except for occurrences in encoded Switch stmt (i.e. remaining Match(CaseDef(...)))

   Definition Classes

   Trees

2. trait AlternativeApi extends Universe.TermTreeApi

   

   The API that all alternatives support

   The API that all alternatives support

   Definition Classes

   Trees

3. abstract class AlternativeExtractor extends AnyRef

   

   An extractor class to create and pattern match with syntax Alternative(trees).

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

   pat1 | ... | patn

   Definition Classes

   Trees

4. abstract type Annotated >: Null <: Universe.AnnotatedApi with Universe.Tree

   

   A tree that has an annotation attached to it.

   A tree that has an annotation attached to it. Only used for annotated types and annotation ascriptions, annotations on definitions are stored in the Modifiers. Eliminated by typechecker (typedAnnotated), the annotations are then stored in an AnnotatedType.

   Definition Classes

   Trees

5. trait AnnotatedApi extends Universe.TreeApi

   

   The API that all annotateds support

   The API that all annotateds support

   Definition Classes

   Trees

6. abstract class AnnotatedExtractor extends AnyRef

   

   An extractor class to create and pattern match with syntax Annotated(annot, arg).

   An extractor class to create and pattern match with syntax Annotated(annot, arg). This AST node corresponds to the following Scala code:

   arg @annot // for types arg: @annot // for exprs

   Definition Classes

   Trees

7. abstract type AnnotatedType >: Null <: Universe.AnnotatedTypeApi with Universe.Type

   

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

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

   Definition Classes

   Types

8. trait AnnotatedTypeApi extends Universe.TypeApi

   

   The API that all annotated types support.

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

   Definition Classes

   Types

9. abstract class AnnotatedTypeExtractor extends AnyRef

   

   An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying).

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

   Definition Classes

   Types

10. abstract type Annotation >: Null <: Universe.AnnotationApi

    

    Information about an annotation.

    Information about an annotation.

    Definition Classes

    Annotations

11. trait AnnotationApi extends AnyRef

    

    The API of Annotation instances.

    The API of Annotation instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

    Definition Classes

    Annotations

12. abstract class AnnotationExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Annotation(tpe, scalaArgs, javaArgs).

    An extractor class to create and pattern match with syntax Annotation(tpe, scalaArgs, javaArgs). Here, tpe is the annotation type, scalaArgs the payload of Scala annotations, and javaArgs the payload of Java annotations.

    Definition Classes

    Annotations

13. abstract type AppliedTypeTree >: Null <: Universe.AppliedTypeTreeApi with Universe.TypTree

    

    Applied type <tpt> [ <args> ], eliminated by RefCheck

    Applied type <tpt> [ <args> ], eliminated by RefCheck

    Definition Classes

    Trees

14. trait AppliedTypeTreeApi extends Universe.TypTreeApi

    

    The API that all applied type trees support

    The API that all applied type trees support

    Definition Classes

    Trees

15. abstract class AppliedTypeTreeExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax AppliedTypeTree(tpt, args).

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

    tpt[args]

    Should only be used with tpt nodes which are types, i.e. which have isType returning true. Otherwise TypeApply should be used instead.

    List[Int] as in val x: List[Int] = ??? // represented as AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))

    def foo[T] = ??? foo[Int] // represented as TypeApply(Ident(<foo>), List(TypeTree(<Int>)))

    Definition Classes

    Trees

16. abstract type Apply >: Null <: Universe.ApplyApi with Universe.GenericApply

    

    Value application

    Value application

    Definition Classes

    Trees

17. trait ApplyApi extends Universe.GenericApplyApi

    

    The API that all applies support

    The API that all applies support

    Definition Classes

    Trees

18. abstract class ApplyExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Apply(fun, args).

    An extractor class to create and pattern match with syntax Apply(fun, args). This AST node corresponds to the following Scala code:

    fun(args)

    For instance:

    fun[targs](args)

    Is expressed as:

    Apply(TypeApply(fun, targs), args)

    Definition Classes

    Trees

19. abstract type Assign >: Null <: Universe.AssignApi with Universe.TermTree

    

    Assignment

    Assignment

    Definition Classes

    Trees

20. trait AssignApi extends Universe.TermTreeApi

    

    The API that all assigns support

    The API that all assigns support

    Definition Classes

    Trees

21. abstract class AssignExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Assign(lhs, rhs).

    An extractor class to create and pattern match with syntax Assign(lhs, rhs). This AST node corresponds to the following Scala code:

    lhs = rhs

    Definition Classes

    Trees

22. abstract type AssignOrNamedArg >: Null <: Universe.AssignOrNamedArgApi with Universe.TermTree

    

    Either an assignment or a named argument.

    Either an assignment or a named argument. Only appears in argument lists, eliminated by compiler phase typecheck (doTypedApply), resurrected by reifier.

    Definition Classes

    Trees

23. trait AssignOrNamedArgApi extends Universe.TermTreeApi

    

    The API that all assigns support

    The API that all assigns support

    Definition Classes

    Trees

24. abstract class AssignOrNamedArgExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs).

    An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs). This AST node corresponds to the following Scala code:

    m.f(lhs = rhs)

    @annotation(lhs = rhs)

    Definition Classes

    Trees

25. abstract type Bind >: Null <: Universe.BindApi with Universe.DefTree

    

    Bind a variable to a rhs pattern.

    Bind a variable to a rhs pattern.

    Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

    Definition Classes

    Trees

26. trait BindApi extends Universe.DefTreeApi

    

    The API that all binds support

    The API that all binds support

    Definition Classes

    Trees

27. abstract class BindExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Bind(name, body).

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

    pat*

    Definition Classes

    Trees

28. abstract type Block >: Null <: Universe.BlockApi with Universe.TermTree

    

    Block of expressions (semicolon separated expressions)

    Block of expressions (semicolon separated expressions)

    Definition Classes

    Trees

29. trait BlockApi extends Universe.TermTreeApi

    

    The API that all blocks support

    The API that all blocks support

    Definition Classes

    Trees

30. abstract class BlockExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Block(stats, expr).

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

    { stats; expr }

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

    Definition Classes

    Trees

31. case class BooleanFlag(value: Option[Boolean]) extends Product with Serializable

    
    Definition Classes

    Printers

32. abstract type BoundedWildcardType >: Null <: Universe.BoundedWildcardTypeApi with Universe.Type

    

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

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

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

    Definition Classes

    Types

33. trait BoundedWildcardTypeApi extends Universe.TypeApi

    

    The API that all this types support.

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

    Definition Classes

    Types

34. abstract class BoundedWildcardTypeExtractor extends AnyRef

    

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

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

    Definition Classes

    Types

35. abstract type CaseDef >: Null <: Universe.CaseDefApi with Universe.Tree

    

    Case clause in a pattern match.

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

    Definition Classes

    Trees

36. trait CaseDefApi extends Universe.TreeApi

    

    The API that all case defs support

    The API that all case defs support

    Definition Classes

    Trees

37. abstract class CaseDefExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax CaseDef(pat, guard, body).

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

    case pat if guard => body

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

    Definition Classes

    Trees

38. abstract type ClassDef >: Null <: Universe.ClassDefApi with Universe.ImplDef

    

    A class definition.

    A class definition.

    Definition Classes

    Trees

39. trait ClassDefApi extends Universe.ImplDefApi

    

    The API that all class defs support

    The API that all class defs support

    Definition Classes

    Trees

40. abstract class ClassDefExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl).

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

    mods class name [tparams] impl

    Where impl stands for:

    extends parents { defs }

    Definition Classes

    Trees

41. abstract type ClassInfoType >: Null <: Universe.ClassInfoTypeApi with Universe.CompoundType

    

    The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects.

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

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

    its ClassInfo type has the following form:

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

    Definition Classes

    Types

42. trait ClassInfoTypeApi extends Universe.TypeApi

    

    The API that all class info types support.

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

    Definition Classes

    Types

43. abstract class ClassInfoTypeExtractor extends AnyRef

    

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

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

    Definition Classes

    Types

44. trait ClassMirror extends Universe.TemplateMirror

    

    A mirror that reflects the instance parts of a runtime class.

    A mirror that reflects the instance parts of a runtime class. See the overview page for details on how to use runtime reflection.

    Definition Classes

    Mirrors

45. abstract type ClassSymbol >: Null <: Universe.ClassSymbolApi with Universe.TypeSymbol

    

    The type of class symbols representing class and trait definitions.

    The type of class symbols representing class and trait definitions.

    Definition Classes

    Symbols

46. trait ClassSymbolApi extends Universe.TypeSymbolApi

    

    The API of class symbols.

    The API of class symbols. The main source of information about symbols is the Symbols page.

    Class Symbol defines isXXX test methods such as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, Nil or other empty values.

    Definition Classes

    Symbols

47. abstract type Compat <: MacroCompatApi

    
    Definition Classes

    Universe → Internals

48. trait CompatApi extends AnyRef

    
    Definition Classes

    Internals

    See also

    compat

49. class CompatToken extends AnyRef

    

    Presence of an implicit value of this type in scope indicates that source compatibility with Scala 2.10 has been enabled.

    Presence of an implicit value of this type in scope indicates that source compatibility with Scala 2.10 has been enabled.

    Definition Classes

    Internals

    Annotations

    @implicitNotFound( ... )

50. abstract type CompoundType >: Null <: Universe.CompoundTypeApi with Universe.Type

    

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

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

    Definition Classes

    Types

51. trait CompoundTypeApi extends AnyRef

    

    Has no special methods.

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

    Definition Classes

    Types

52. abstract type CompoundTypeTree >: Null <: Universe.CompoundTypeTreeApi with Universe.TypTree

    

    Intersection type <parent1> with ...

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

    Definition Classes

    Trees

53. trait CompoundTypeTreeApi extends Universe.TypTreeApi

    

    The API that all compound type trees support

    The API that all compound type trees support

    Definition Classes

    Trees

54. abstract class CompoundTypeTreeExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax CompoundTypeTree(templ).

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

    parent1 with ... with parentN { refinement }

    Definition Classes

    Trees

55. abstract type Constant >: Null <: Universe.ConstantApi

    

    This "virtual" case class represents the reflection interface for literal expressions which can not be further broken down or evaluated, such as "true", "0", "classOf[List]".

    This "virtual" case class represents the reflection interface for literal expressions which can not be further broken down or evaluated, such as "true", "0", "classOf[List]". Such values become parts of the Scala abstract syntax tree representing the program. The constants correspond to section 6.24 "Constant Expressions" of the Scala Language Specification.

    Such constants are used to represent literals in abstract syntax trees (the scala.reflect.api.Trees#Literal node) and literal arguments for Java class file annotations (the scala.reflect.api.Annotations#LiteralArgument class).

    Constants can be matched against and can be constructed directly, as if they were case classes:

    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 instances can wrap certain kinds of these expressions:

    1. Literals of primitive value classes (Byte, Short, Int, Long, Float, Double, Char, Boolean and Unit) - represented directly as the corresponding type
    2. String literals - represented as instances of the String.
    3. References to classes, typically constructed with scala.Predef#classOf - represented as types.
    4. References to enumeration values - represented as symbols.

    Class references are represented as instances of scala.reflect.api.Types#Type (because when the Scala compiler processes a class reference, the underlying runtime class might not yet have been compiled). To convert such a reference to a runtime class, one should use the runtimeClass method of a mirror such as RuntimeMirror (the simplest way to get such a mirror is using scala.reflect.runtime.currentMirror).

    Enumeration value references are represented as instances of scala.reflect.api.Symbols#Symbol, which on JVM point to methods that return underlying enum values. To inspect an underlying enumeration or to get runtime value of a reference to an enum, one should use a scala.reflect.api.Mirrors#RuntimeMirror (the simplest way to get such a mirror is again scala.reflect.runtime.package#currentMirror).

    Usage example:

    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
        case _ => sys.error("Not a constant")
      }
    
      val classRef = jarg("classRef").value.asInstanceOf[Type]
                                             // ideally one should match instead of casting
      println(showRaw(classRef))             // TypeRef(ThisType(), 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://issues.scala-lang.org/browse/SI-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
    }

    Definition Classes

    Constants

56. abstract class ConstantApi extends AnyRef

    

    The API of Constant instances.

    The API of Constant instances.

    Definition Classes

    Constants

57. abstract class ConstantExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Constant(value) where value is the Scala value of the constant.

    An extractor class to create and pattern match with syntax Constant(value) where value is the Scala value of the constant.

    Definition Classes

    Constants

58. abstract type ConstantType >: Null <: Universe.ConstantTypeApi with Universe.SingletonType

    

    The ConstantType type is not directly written in user programs, but arises as the type of a constant.

    The ConstantType type is not directly written in user programs, but arises as the type of a constant. The REPL expresses constant types like Int(11). Here are some constants with their types:

    1           ConstantType(Constant(1))
    "abc"       ConstantType(Constant("abc"))

    Definition Classes

    Types

59. trait ConstantTypeApi extends Universe.TypeApi

    

    The API that all constant types support.

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

    Definition Classes

    Types

60. abstract class ConstantTypeExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax ConstantType(constant) Here, constant is the constant value represented by the type.

    An extractor class to create and pattern match with syntax ConstantType(constant) Here, constant is the constant value represented by the type.

    Definition Classes

    Types

61. abstract type DefDef >: Null <: Universe.DefDefApi with Universe.ValOrDefDef

    

    A method or macro definition.

    A method or macro definition.

    Definition Classes

    Trees

62. trait DefDefApi extends Universe.ValOrDefDefApi

    

    The API that all def defs support

    The API that all def defs support

    Definition Classes

    Trees

63. abstract class DefDefExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs).

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

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

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

    Definition Classes

    Trees

64. abstract type DefTree >: Null <: Universe.DefTreeApi with Universe.SymTree with Universe.NameTree

    

    A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2) Bind that is used to represent binding occurrences in pattern matches 3) LabelDef that is used internally to represent while loops

    A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2) Bind that is used to represent binding occurrences in pattern matches 3) LabelDef that is used internally to represent while loops

    Definition Classes

    Trees

65. trait DefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

    

    The API that all def trees support

    The API that all def trees support

    Definition Classes

    Trees

66. trait DefinitionsApi extends Universe.StandardTypes

    

    Defines standard symbols (and types via its base trait).

    Defines standard symbols (and types via its base trait).

    Definition Classes

    StandardDefinitions

67. abstract type ExistentialType >: Null <: Universe.ExistentialTypeApi with Universe.Type

    

    The ExistentialType type signature is used for existential types and wildcard types.

    The ExistentialType type signature is used for existential types and wildcard types.

    Definition Classes

    Types

68. trait ExistentialTypeApi extends Universe.TypeApi

    

    The API that all existential types support.

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

    Definition Classes

    Types

69. abstract class ExistentialTypeExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying).

    An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying). Here, quantified are the type variables bound by the existential type and underlying is the type that's existentially quantified.

    Definition Classes

    Types

70. abstract type ExistentialTypeTree >: Null <: Universe.ExistentialTypeTreeApi with Universe.TypTree

    

    Existential type tree node

    Existential type tree node

    Definition Classes

    Trees

71. trait ExistentialTypeTreeApi extends Universe.TypTreeApi

    

    The API that all existential type trees support

    The API that all existential type trees support

    Definition Classes

    Trees

72. abstract class ExistentialTypeTreeExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses).

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

    tpt forSome { whereClauses }

    Definition Classes

    Trees

73. trait Expr[+T] extends Equals with Serializable

    

    Expr wraps an abstract syntax tree and tags it with its type.

    Expr wraps an abstract syntax tree and tags it with its type. The main source of information about exprs is the scala.reflect.api.Exprs page.

    Definition Classes

    Exprs

74. trait FieldMirror extends AnyRef

    

    A mirror that reflects a field.

    A mirror that reflects a field. See the overview page for details on how to use runtime reflection.

    Definition Classes

    Mirrors

75. trait FlagOps extends Any

    

    The API of FlagSet instances.

    The API of FlagSet instances. The main source of information about flag sets is the scala.reflect.api.FlagSets page.

    Definition Classes

    FlagSets

76. abstract type FlagSet

    

    An abstract type representing sets of flags (like private, final, etc.) that apply to definition trees and symbols

    An abstract type representing sets of flags (like private, final, etc.) that apply to definition trees and symbols

    Definition Classes

    FlagSets

77. trait FlagValues extends AnyRef

    

    All possible values that can constitute flag sets.

    All possible values that can constitute flag sets. The main source of information about flag sets is the scala.reflect.api.FlagSets page.

    Definition Classes

    FlagSets

78. abstract type FreeTermSymbol >: Null <: Universe.FreeTermSymbolApi with Universe.TermSymbol

    

    The type of free terms introduced by reification.

    The type of free terms introduced by reification.

    Definition Classes

    Internals

79. trait FreeTermSymbolApi extends Universe.TermSymbolApi

    

    The API of free term symbols.

    The API of free term symbols. The main source of information about symbols is the Symbols page.

    $SYMACCESSORS

    Definition Classes

    Internals

80. abstract type FreeTypeSymbol >: Null <: Universe.FreeTypeSymbolApi with Universe.TypeSymbol

    

    The type of free types introduced by reification.

    The type of free types introduced by reification.

    Definition Classes

    Internals

81. trait FreeTypeSymbolApi extends Universe.TypeSymbolApi

    

    The API of free type symbols.

    The API of free type symbols. The main source of information about symbols is the Symbols page.

    $SYMACCESSORS

    Definition Classes

    Internals

82. abstract type Function >: Null <: Universe.FunctionApi with Universe.TermTree with Universe.SymTree

    

    Anonymous function, eliminated by compiler phase lambdalift

    Anonymous function, eliminated by compiler phase lambdalift

    Definition Classes

    Trees

83. trait FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi

    

    The API that all functions support

    The API that all functions support

    Definition Classes

    Trees

84. abstract class FunctionExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Function(vparams, body).

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

    vparams => body

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

    Definition Classes

    Trees

85. abstract type GenericApply >: Null <: Universe.GenericApplyApi with Universe.TermTree

    

    Common base class for Apply and TypeApply.

    Common base class for Apply and TypeApply.

    Definition Classes

    Trees

86. trait GenericApplyApi extends Universe.TermTreeApi

    

    The API that all applies support

    The API that all applies support

    Definition Classes

    Trees

87. abstract type Ident >: Null <: Universe.IdentApi with Universe.RefTree

    

    A reference to identifier name.

    A reference to identifier name.

    Definition Classes

    Trees

88. trait IdentApi extends Universe.RefTreeApi

    

    The API that all idents support

    The API that all idents support

    Definition Classes

    Trees

89. abstract class IdentExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Ident(qual, name).

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

    name

    Type checker converts idents that refer to enclosing fields or methods to selects. For example, name ==> this.name

    Definition Classes

    Trees

90. abstract type If >: Null <: Universe.IfApi with Universe.TermTree

    

    Conditional expression

    Conditional expression

    Definition Classes

    Trees

91. trait IfApi extends Universe.TermTreeApi

    

    The API that all ifs support

    The API that all ifs support

    Definition Classes

    Trees

92. abstract class IfExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax If(cond, thenp, elsep).

    An extractor class to create and pattern match with syntax If(cond, thenp, elsep). This AST node corresponds to the following Scala code:

    if (cond) thenp else elsep

    If the alternative is not present, the elsep is set to Literal(Constant(())).

    Definition Classes

    Trees

93. abstract type ImplDef >: Null <: Universe.ImplDefApi with Universe.MemberDef

    

    A common base class for class and object definitions.

    A common base class for class and object definitions.

    Definition Classes

    Trees

94. trait ImplDefApi extends Universe.MemberDefApi

    

    The API that all impl defs support

    The API that all impl defs support

    Definition Classes

    Trees

95. abstract type Import >: Null <: Universe.ImportApi with Universe.SymTree

    

    Import clause

    Import clause

    Definition Classes

    Trees

96. trait ImportApi extends Universe.SymTreeApi

    

    The API that all imports support

    The API that all imports support

    Definition Classes

    Trees

97. abstract class ImportExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Import(expr, selectors).

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

    import expr.{selectors}

    Selectors are a list of ImportSelectors, which conceptually are pairs of names (from, to). The last (and maybe only name) may be a nme.WILDCARD. For instance:

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

    Would be represented as:

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

    The symbol of an Import is an import symbol @see Symbol.newImport. It's used primarily as a marker to check that the import has been typechecked.

    Definition Classes

    Trees

98. abstract type ImportSelector >: Null <: Universe.ImportSelectorApi

    

    Import selector (not a tree, but a component of the Import tree)

    Import selector (not a tree, but a component of the Import tree)

    Representation of an imported name its optional rename and their optional positions

    Eliminated by typecheck.

    Definition Classes

    Trees

99. trait ImportSelectorApi extends AnyRef

    

    The API that all import selectors support

    The API that all import selectors support

    Definition Classes

    Trees

100. abstract class ImportSelectorExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos).

     An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos). This is not an AST node, it is used as a part of the Import node.

     Definition Classes

     Trees

101. trait Importer extends AnyRef

     

     This trait provides support for importers, a facility to migrate reflection artifacts between universes.

     This trait provides support for importers, a facility to migrate reflection artifacts between universes. Note: this trait should typically be used only rarely.

     Reflection artifacts, such as Symbols and Types, are contained in Universes. Typically all processing happens within a single Universe (e.g. a compile-time macro Universe or a runtime reflection Universe), but sometimes there is a need to migrate artifacts from one Universe to another. For example, runtime compilation works by importing runtime reflection trees into a runtime compiler universe, compiling the importees and exporting the result back.

     Reflection artifacts are firmly grounded in their Universes, which is reflected by the fact that types of artifacts from different universes are not compatible. By using Importers, however, they be imported from one universe into another. For example, to import foo.bar.Baz from the source Universe to the target Universe, an importer will first check whether the entire owner chain exists in the target Universe. If it does, then nothing else will be done. Otherwise, the importer will recreate the entire owner chain and will import the corresponding type signatures into the target Universe.

     Since importers match Symbol tables of the source and the target Universes using plain string names, it is programmer's responsibility to make sure that imports don't distort semantics, e.g., that foo.bar.Baz in the source Universe means the same that foo.bar.Baz does in the target Universe.

     Example

     Here's how one might implement a macro that performs compile-time evaluation of its argument by using a runtime compiler to compile and evaluate a tree that belongs to a compile-time compiler:

     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]
       ...
     }

     Definition Classes

     Internals

102. trait InstanceMirror extends AnyRef

     

     A mirror that reflects a runtime value.

     A mirror that reflects a runtime value. See the overview page for details on how to use runtime reflection.

     Definition Classes

     Mirrors

103. abstract type Internal <: MacroInternalApi

     
     Definition Classes

     Universe → Internals

104. trait InternalApi extends AnyRef

     

     Reflection API exhibits a tension inherent to experimental things: on the one hand we want it to grow into a beautiful and robust API, but on the other hand we have to deal with immaturity of underlying mechanisms by providing not very pretty solutions to enable important use cases.

     Reflection API exhibits a tension inherent to experimental things: on the one hand we want it to grow into a beautiful and robust API, but on the other hand we have to deal with immaturity of underlying mechanisms by providing not very pretty solutions to enable important use cases.

     In Scala 2.10, which was our first stab at reflection API, we didn't have a systematic approach to dealing with this tension, sometimes exposing too much of internals (e.g. Symbol.deSkolemize) and sometimes exposing too little (e.g. there's still no facility to change owners, to do typing transformations, etc). This resulted in certain confusion with some internal APIs living among public ones, scaring the newcomers, and some internal APIs only available via casting, which requires intimate knowledge of the compiler and breaks compatibility guarantees.

     This led to creation of the internal API module for the reflection API, which provides advanced APIs necessary for macros that push boundaries of the state of the art, clearly demarcating them from the more or less straightforward rest and providing compatibility guarantees on par with the rest of the reflection API (full compatibility within minor releases, best effort towards backward compatibility within major releases, clear replacement path in case of rare incompatible changes in major releases).

     The internal module itself (the value that implements InternalApi) isn't defined here, in scala.reflect.api.Universe, but is provided on per-implementation basis. Runtime API endpoint (scala.reflect.runtime.universe) provides universe.compat: InternalApi, whereas compile-time API endpoints (instances of scala.reflect.macros.Context) provide c.compat: ContextInternalApi, which extends InternalApi with additional universe-specific and context-specific functionality.

     Definition Classes

     Internals

105. abstract type LabelDef >: Null <: Universe.LabelDefApi with Universe.DefTree with Universe.TermTree

     

     A labelled expression.

     A labelled expression. Not expressible in language syntax, but generated by the compiler to simulate while/do-while loops, and also by the pattern matcher.

     The label acts much like a nested function, where params represents the incoming parameters. The symbol given to the LabelDef should have a MethodType, as if it were a nested function.

     Jumps are apply nodes attributed with a label's symbol. The arguments from the apply node will be passed to the label and assigned to the Idents.

     Forward jumps within a block are allowed.

     Definition Classes

     Trees

106. trait LabelDefApi extends Universe.DefTreeApi with Universe.TermTreeApi

     

     The API that all label defs support

     The API that all label defs support

     Definition Classes

     Trees

107. abstract class LabelDefExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax LabelDef(name, params, rhs).

     An extractor class to create and pattern match with syntax LabelDef(name, params, rhs).

     This AST node does not have direct correspondence to Scala code. It is used for tailcalls and like. For example, while/do are desugared to label defs as follows:

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

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

     Definition Classes

     Trees

108. trait Liftable[T] extends AnyRef

     

     A type class that defines a representation of T as a Tree.

     A type class that defines a representation of T as a Tree.

     Definition Classes

     Liftables

     See also

     http://docs.scala-lang.org/overviews/quasiquotes/lifting.html

109. abstract type Literal >: Null <: Universe.LiteralApi with Universe.TermTree

     

     Literal

     Literal

     Definition Classes

     Trees

110. trait LiteralApi extends Universe.TermTreeApi

     

     The API that all literals support

     The API that all literals support

     Definition Classes

     Trees

111. abstract class LiteralExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Literal(value).

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

     value

     Definition Classes

     Trees

112. trait MacroCompatApi extends CompatApi

     
     See also

     compat

113. trait MacroInternalApi extends InternalApi

     

     <invalid inheritdoc annotation>

114. abstract type Match >: Null <: Universe.MatchApi with Universe.TermTree

     

     - Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)

     - Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)

     • Switch statements (after compiler phase explicitouter before 2.10 / patmat from 2.10)

     After compiler phase explicitouter before 2.10 / patmat from 2.10, cases will satisfy the following constraints:

     • all guards are EmptyTree,
     • all patterns will be either Literal(Constant(x:Int)) or Alternative(lit|...|lit)
     • except for an "otherwise" branch, which has pattern Ident(nme.WILDCARD)

     Definition Classes

     Trees

115. trait MatchApi extends Universe.TermTreeApi

     

     The API that all matches support

     The API that all matches support

     Definition Classes

     Trees

116. abstract class MatchExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Match(selector, cases).

     An extractor class to create and pattern match with syntax Match(selector, cases). This AST node corresponds to the following Scala code:

     selector match { cases }

     Match is also used in pattern matching assignments like val (foo, bar) = baz.

     Definition Classes

     Trees

117. abstract type MemberDef >: Null <: Universe.MemberDefApi with Universe.DefTree

     

     Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.

     Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.

     Definition Classes

     Trees

118. trait MemberDefApi extends Universe.DefTreeApi

     

     The API that all member defs support

     The API that all member defs support

     Definition Classes

     Trees

119. abstract type MemberScope >: Null <: Universe.MemberScopeApi with Universe.Scope

     

     The type of member scopes, as in class definitions, for example.

     The type of member scopes, as in class definitions, for example.

     Definition Classes

     Scopes

120. trait MemberScopeApi extends Universe.ScopeApi

     

     The API that all member scopes support

     The API that all member scopes support

     Definition Classes

     Scopes

121. trait MethodMirror extends AnyRef

     

     A mirror that reflects a method.

     A mirror that reflects a method. See the overview page for details on how to use runtime reflection.

     Definition Classes

     Mirrors

122. abstract type MethodSymbol >: Null <: Universe.MethodSymbolApi with Universe.TermSymbol

     

     The type of method symbols representing def declarations.

     The type of method symbols representing def declarations.

     Definition Classes

     Symbols

123. trait MethodSymbolApi extends Universe.TermSymbolApi

     

     The API of method symbols.

     The API of method symbols. The main source of information about symbols is the Symbols page.

     Class Symbol defines isXXX test methods such as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, Nil or other empty values.

     Definition Classes

     Symbols

124. abstract type MethodType >: Null <: Universe.MethodTypeApi with Universe.Type

     

     The MethodType type signature is used to indicate parameters and result type of a method

     The MethodType type signature is used to indicate parameters and result type of a method

     Definition Classes

     Types

125. trait MethodTypeApi extends Universe.TypeApi

     

     The API that all method types support.

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

     Definition Classes

     Types

126. abstract class MethodTypeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax MethodType(params, respte) Here, params is a potentially empty list of parameter symbols of the method, and restpe is the result type of the method.

     An extractor class to create and pattern match with syntax MethodType(params, respte) Here, params is a potentially empty list of parameter symbols of the method, and restpe is the result type of the method. If the method is curried, restpe would be another MethodType. Note: MethodType(Nil, Int) would be the type of a method defined with an empty parameter list.

     def f(): Int

     If the method is completely parameterless, as in

     def f: Int

     its type is a NullaryMethodType.

     Definition Classes

     Types

127. abstract type Mirror >: Null <: api.Mirror[Universe.this.type]

     

     The base type of all mirrors of this universe.

     The base type of all mirrors of this universe.

     This abstract type conforms the base interface for all mirrors defined in scala.reflect.api.Mirror and is gradually refined in specific universes (e.g. Mirror of a scala.reflect.api.JavaUniverse is capable of reflection).

     Definition Classes

     Mirrors

128. abstract type Modifiers >: Null <: ModifiersApi

     

     The type of tree modifiers (not a tree, but rather part of DefTrees).

     The type of tree modifiers (not a tree, but rather part of DefTrees).

     Definition Classes

     Trees

129. abstract class ModifiersApi extends AnyRef

     

     The API that all Modifiers support

     The API that all Modifiers support

     Definition Classes

     Trees

130. abstract class ModifiersExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Modifiers(flags, privateWithin, annotations).

     An extractor class to create and pattern match with syntax Modifiers(flags, privateWithin, annotations). Modifiers encapsulate flags, visibility annotations and Scala annotations for member definitions.

     Definition Classes

     Trees

131. abstract type ModuleDef >: Null <: Universe.ModuleDefApi with Universe.ImplDef

     

     An object definition, e.g.

     An object definition, e.g. object Foo. Internally, objects are quite frequently called modules to reduce ambiguity. Eliminated by compiler phase refcheck.

     Definition Classes

     Trees

132. trait ModuleDefApi extends Universe.ImplDefApi

     

     The API that all module defs support

     The API that all module defs support

     Definition Classes

     Trees

133. abstract class ModuleDefExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax ModuleDef(mods, name, impl).

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

     mods object name impl

     Where impl stands for:

     extends parents { defs }

     Definition Classes

     Trees

134. trait ModuleMirror extends Universe.TemplateMirror

     

     A mirror that reflects a Scala object definition or the static parts of a runtime class.

     A mirror that reflects a Scala object definition or the static parts of a runtime class. See the overview page for details on how to use runtime reflection.

     Definition Classes

     Mirrors

135. abstract type ModuleSymbol >: Null <: Universe.ModuleSymbolApi with Universe.TermSymbol

     

     The type of module symbols representing object declarations.

     The type of module symbols representing object declarations.

     Definition Classes

     Symbols

136. trait ModuleSymbolApi extends Universe.TermSymbolApi

     

     The API of module symbols.

     The API of module symbols. The main source of information about symbols is the Symbols page.

     Class Symbol defines isXXX test methods such as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, Nil or other empty values.

     Definition Classes

     Symbols

137. abstract type Name >: Null <: NameApi

     

     The abstract type of names.

     The abstract type of names.

     Definition Classes

     Names

138. abstract class NameApi extends AnyRef

     

     The API of Name instances.

     The API of Name instances.

     Definition Classes

     Names

139. abstract type NameTree >: Null <: Universe.NameTreeApi with Universe.Tree

     

     A tree that carries a name, e.g.

     A tree that carries a name, e.g. by defining it (DefTree) or by referring to it (RefTree).

     Definition Classes

     Trees

140. trait NameTreeApi extends Universe.TreeApi

     

     The API that all name trees support

     The API that all name trees support

     Definition Classes

     Trees

141. trait NamesApi extends AnyRef

     

     Defines standard names, common for term and type names: These can be accessed via the nme and tpnme members.

     Defines standard names, common for term and type names: These can be accessed via the nme and tpnme members.

     Definition Classes

     StandardNames

142. abstract type New >: Null <: Universe.NewApi with Universe.TermTree

     

     Object instantiation

     Object instantiation

     Definition Classes

     Trees

143. trait NewApi extends Universe.TermTreeApi

     

     The API that all news support

     The API that all news support

     Definition Classes

     Trees

144. abstract class NewExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax New(tpt).

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

     new T

     This node always occurs in the following context:

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

     For example, an AST representation of:

     new Example[Int](2)(3)

     is the following code:

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

     Definition Classes

     Trees

145. abstract type NullaryMethodType >: Null <: Universe.NullaryMethodTypeApi with Universe.Type

     

     The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T

     The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T

     Definition Classes

     Types

146. trait NullaryMethodTypeApi extends Universe.TypeApi

     

     The API that all nullary method types support.

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

     Definition Classes

     Types

147. abstract class NullaryMethodTypeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax NullaryMethodType(resultType).

     An extractor class to create and pattern match with syntax NullaryMethodType(resultType). Here, resultType is the result type of the parameterless method.

     Definition Classes

     Types

148. abstract type PackageDef >: Null <: Universe.PackageDefApi with Universe.MemberDef

     

     A packaging, such as package pid { stats }

     A packaging, such as package pid { stats }

     Definition Classes

     Trees

149. trait PackageDefApi extends Universe.MemberDefApi

     

     The API that all package defs support

     The API that all package defs support

     Definition Classes

     Trees

150. abstract class PackageDefExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax PackageDef(pid, stats).

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

     package pid { stats }

     Definition Classes

     Trees

151. abstract type PolyType >: Null <: Universe.PolyTypeApi with Universe.Type

     

     The PolyType type signature is used for polymorphic methods that have at least one type parameter.

     The PolyType type signature is used for polymorphic methods that have at least one type parameter.

     Definition Classes

     Types

152. trait PolyTypeApi extends Universe.TypeApi

     

     The API that all polymorphic types support.

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

     Definition Classes

     Types

153. abstract class PolyTypeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax PolyType(typeParams, resultType).

     An extractor class to create and pattern match with syntax PolyType(typeParams, resultType). Here, typeParams are the type parameters of the method and resultType is the type signature following the type parameters.

     Definition Classes

     Types

154. abstract type Position >: Null <: api.Position { type Pos = Universe.this.Position }

     

     Defines a universe-specific notion of positions.

     Defines a universe-specific notion of positions. The main documentation entry about positions is located at scala.reflect.api.Position.

     Definition Classes

     Positions

155. implicit class Quasiquote extends AnyRef

     

     Implicit class that introduces q, tq, cq, pq and fq string interpolators that are also known as quasiquotes.

     Implicit class that introduces q, tq, cq, pq and fq string interpolators that are also known as quasiquotes. With their help you can easily manipulate Scala reflection ASTs.

     Definition Classes

     Quasiquotes

     See also

     http://docs.scala-lang.org/overviews/quasiquotes/intro.html

156. abstract type RefTree >: Null <: Universe.RefTreeApi with Universe.SymTree with Universe.NameTree

     

     A tree which references a symbol-carrying entity.

     A tree which references a symbol-carrying entity. References one, as opposed to defining one; definitions are in DefTrees.

     Definition Classes

     Trees

157. trait RefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

     

     The API that all ref trees support

     The API that all ref trees support

     Definition Classes

     Trees

158. abstract class RefTreeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax RefTree(qual, name).

     An extractor class to create and pattern match with syntax RefTree(qual, name). This AST node corresponds to either Ident, Select or SelectFromTypeTree.

     Definition Classes

     Trees

159. abstract type ReferenceToBoxed >: Null <: Universe.ReferenceToBoxedApi with Universe.TermTree

     

     Marks underlying reference to id as boxed.

     Marks underlying reference to id as boxed.

     Precondition: id must refer to a captured variable A reference such marked will refer to the boxed entity, no dereferencing with .elem is done on it. This tree node can be emitted by macros such as reify that call referenceCapturedVariable. It is eliminated in LambdaLift, where the boxing conversion takes place.

     Definition Classes

     Internals

160. trait ReferenceToBoxedApi extends Universe.TermTreeApi

     

     The API that all references support

     The API that all references support

     Definition Classes

     Internals

161. abstract class ReferenceToBoxedExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax ReferenceToBoxed(ident).

     An extractor class to create and pattern match with syntax ReferenceToBoxed(ident). This AST node does not have direct correspondence to Scala code, and is emitted by macros to reference capture vars directly without going through elem.

     For example:

     var x = ... fun { x }

     Will emit:

     Ident(x)

     Which gets transformed to:

     Select(Ident(x), "elem")

     If ReferenceToBoxed were used instead of Ident, no transformation would be performed.

     Definition Classes

     Internals

162. abstract type RefinedType >: Null <: Universe.RefinedTypeApi with Universe.CompoundType

     

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

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

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

     Definition Classes

     Types

163. trait RefinedTypeApi extends Universe.TypeApi

     

     The API that all refined types support.

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

     Definition Classes

     Types

164. abstract class RefinedTypeExtractor extends AnyRef

     

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

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

     Definition Classes

     Types

165. trait ReflectiveMirror extends api.Mirror[Mirrors.this.type]

     

     A mirror that reflects instances and static classes.

     A mirror that reflects instances and static classes. See the overview page for details on how to use runtime reflection.

     Definition Classes

     Mirrors

166. trait ReificationSupportApi extends AnyRef

     

     This is an internal implementation class.

     This is an internal implementation class.

     Definition Classes

     Internals

167. abstract type Return >: Null <: Universe.ReturnApi with Universe.SymTree with Universe.TermTree

     

     Return expression

     Return expression

     Definition Classes

     Trees

168. trait ReturnApi extends Universe.TermTreeApi

     

     The API that all returns support

     The API that all returns support

     Definition Classes

     Trees

169. abstract class ReturnExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Return(expr).

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

     return expr

     The symbol of a Return node is the enclosing method.

     Definition Classes

     Trees

170. abstract type RuntimeClass >: Null <: AnyRef

     

     Abstracts the runtime representation of a class on the underlying platform.

     Abstracts the runtime representation of a class on the underlying platform.

     Definition Classes

     Mirrors

171. trait RuntimeClassApi extends AnyRef

     

     Has no special methods.

     Has no special methods. Is here to provides erased identity for RuntimeClass.

     Definition Classes

     Mirrors

172. trait RuntimeMirror extends api.Mirror[Mirrors.this.type] with Universe.ReflectiveMirror

     

     The API of a mirror for a reflective universe.

     The API of a mirror for a reflective universe. See the overview page for details on how to use runtime reflection.

     Definition Classes

     Mirrors

173. abstract type Scope >: Null <: Universe.ScopeApi

     

     The base type of all scopes.

     The base type of all scopes.

     Definition Classes

     Scopes

174. trait ScopeApi extends Iterable[Universe.Symbol]

     

     The API that all scopes support

     The API that all scopes support

     Definition Classes

     Scopes

175. abstract type Select >: Null <: Universe.SelectApi with Universe.RefTree

     

     A member selection <qualifier> .

     A member selection <qualifier> . <name>

     Definition Classes

     Trees

176. trait SelectApi extends Universe.RefTreeApi

     

     The API that all selects support

     The API that all selects support

     Definition Classes

     Trees

177. abstract class SelectExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Select(qual, name).

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

     qualifier.selector

     Should only be used with qualifier nodes which are terms, i.e. which have isTerm returning true. Otherwise SelectFromTypeTree should be used instead.

     foo.Bar // represented as Select(Ident(<foo>), <Bar>) Foo#Bar // represented as SelectFromTypeTree(Ident(<Foo>), <Bar>)

     Definition Classes

     Trees

178. abstract type SelectFromTypeTree >: Null <: Universe.SelectFromTypeTreeApi with Universe.TypTree with Universe.RefTree

     

     Type selection <qualifier> # <name>, eliminated by RefCheck

     Type selection <qualifier> # <name>, eliminated by RefCheck

     Definition Classes

     Trees

179. trait SelectFromTypeTreeApi extends Universe.TypTreeApi with Universe.RefTreeApi

     

     The API that all selects from type trees support

     The API that all selects from type trees support

     Definition Classes

     Trees

180. abstract class SelectFromTypeTreeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax SelectFromTypeTree(qualifier, name).

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

     qualifier # selector

     Note: a path-dependent type p.T is expressed as p.type # T

     Should only be used with qualifier nodes which are types, i.e. which have isType returning true. Otherwise Select should be used instead.

     Foo#Bar // represented as SelectFromTypeTree(Ident(<Foo>), <Bar>) foo.Bar // represented as Select(Ident(<foo>), <Bar>)

     Definition Classes

     Trees

181. abstract type SingleType >: Null <: Universe.SingleTypeApi with Universe.SingletonType

     

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

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

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

     Definition Classes

     Types

182. trait SingleTypeApi extends Universe.TypeApi

     

     The API that all single types support.

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

     Definition Classes

     Types

183. abstract class SingleTypeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax SingleType(pre, sym) Here, pre is the prefix of the single-type, and sym is the stable value symbol referred to by the single-type.

     An extractor class to create and pattern match with syntax SingleType(pre, sym) Here, pre is the prefix of the single-type, and sym is the stable value symbol referred to by the single-type.

     Definition Classes

     Types

184. abstract type SingletonType >: Null <: Universe.SingletonTypeApi with Universe.Type

     

     The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value.

     The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value. These include types of the forms

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

     as well as constant types.

     Definition Classes

     Types

185. trait SingletonTypeApi extends AnyRef

     

     Has no special methods.

     Has no special methods. Is here to provides erased identity for SingletonType.

     Definition Classes

     Types

186. abstract type SingletonTypeTree >: Null <: Universe.SingletonTypeTreeApi with Universe.TypTree

     

     Singleton type, eliminated by RefCheck

     Singleton type, eliminated by RefCheck

     Definition Classes

     Trees

187. trait SingletonTypeTreeApi extends Universe.TypTreeApi

     

     The API that all singleton type trees support

     The API that all singleton type trees support

     Definition Classes

     Trees

188. abstract class SingletonTypeTreeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax SingletonTypeTree(ref).

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

     ref.type

     Definition Classes

     Trees

189. trait StandardLiftableInstances extends AnyRef

     

     Definition Classes

     StandardLiftables

190. trait StandardTypes extends AnyRef

     

     Defines standard types.

     Defines standard types.

     Definition Classes

     StandardDefinitions

191. trait StandardUnliftableInstances extends AnyRef

     

     Definition Classes

     StandardLiftables

192. abstract type Star >: Null <: Universe.StarApi with Universe.TermTree

     

     Repetition of pattern.

     Repetition of pattern.

     Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

     Definition Classes

     Trees

193. trait StarApi extends Universe.TermTreeApi

     

     The API that all stars support

     The API that all stars support

     Definition Classes

     Trees

194. abstract class StarExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Star(elem).

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

     pat*

     Definition Classes

     Trees

195. abstract type Super >: Null <: Universe.SuperApi with Universe.TermTree

     

     Super reference, where qual is the corresponding this reference.

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

     Definition Classes

     Trees

196. trait SuperApi extends Universe.TermTreeApi

     

     The API that all supers support

     The API that all supers support

     Definition Classes

     Trees

197. abstract class SuperExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Super(qual, mix).

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

     C.super[M]

     Which is represented as:

     Super(This(C), M)

     If mix is empty, it is tpnme.EMPTY.

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

     Definition Classes

     Trees

198. abstract type SuperType >: Null <: Universe.SuperTypeApi with Universe.SingletonType

     

     The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType.

     The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType. It's internal presentation is

     SuperType(thistpe, supertpe)

     Here, thistpe is the type of the corresponding this-type. For instance, in the type arising from C.super, the thistpe part would be ThisType(C). supertpe is the type of the super class referred to by the super.

     Definition Classes

     Types

199. trait SuperTypeApi extends Universe.TypeApi

     

     The API that all super types support.

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

     Definition Classes

     Types

200. abstract class SuperTypeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)

     An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)

     Definition Classes

     Types

201. abstract type SymTree >: Null <: Universe.SymTreeApi with Universe.Tree

     

     A tree that carries a symbol, e.g.

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

     Definition Classes

     Trees

202. trait SymTreeApi extends Universe.TreeApi

     

     The API that all sym trees support

     The API that all sym trees support

     Definition Classes

     Trees

203. abstract type Symbol >: Null <: Universe.SymbolApi

     

     The type of symbols representing declarations.

     The type of symbols representing declarations.

     Definition Classes

     Symbols

204. trait SymbolApi extends AnyRef

     

     The API of symbols.

     The API of symbols. The main source of information about symbols is the Symbols page.

     Class Symbol defines isXXX test methods such as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, Nil or other empty values.

     Definition Classes

     Symbols

205. abstract type Template >: Null <: Universe.TemplateApi with Universe.SymTree

     

     Instantiation template of a class or trait

     Instantiation template of a class or trait

     Definition Classes

     Trees

206. trait TemplateApi extends Universe.SymTreeApi

     

     The API that all templates support

     The API that all templates support

     Definition Classes

     Trees

207. abstract class TemplateExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Template(parents, self, body).

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

     extends parents { self => body }

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

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

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

     Definition Classes

     Trees

208. trait TemplateMirror extends AnyRef

     

     A mirror that reflects the instance or static parts of a runtime class.

     A mirror that reflects the instance or static parts of a runtime class. See the overview page for details on how to use runtime reflection.

     Definition Classes

     Mirrors

209. abstract type TermName >: Null <: TermNameApi with Name

     

     The abstract type of names representing types.

     The abstract type of names representing types.

     Definition Classes

     Names

210. trait TermNameApi extends AnyRef

     

     Has no special methods.

     Has no special methods. Is here to provides erased identity for TermName.

     Definition Classes

     Names

211. abstract class TermNameExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax TermName(s).

     An extractor class to create and pattern match with syntax TermName(s).

     Definition Classes

     Names

212. trait TermNamesApi extends Universe.NamesApi

     

     Defines standard term names that can be accessed via the nme member.

     Defines standard term names that can be accessed via the nme member.

     Definition Classes

     StandardNames

213. abstract type TermSymbol >: Null <: Universe.TermSymbolApi with Universe.Symbol

     

     The type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.

     The type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.

     Definition Classes

     Symbols

214. trait TermSymbolApi extends Universe.SymbolApi

     

     The API of term symbols.

     The API of term symbols. The main source of information about symbols is the Symbols page.

     Class Symbol defines isXXX test methods such as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, Nil or other empty values.

     Definition Classes

     Symbols

215. abstract type TermTree >: Null <: Universe.TermTreeApi with Universe.Tree

     

     A tree for a term.

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

     Definition Classes

     Trees

216. trait TermTreeApi extends Universe.TreeApi

     

     The API that all term trees support

     The API that all term trees support

     Definition Classes

     Trees

217. abstract type This >: Null <: Universe.ThisApi with Universe.TermTree with Universe.SymTree

     

     Self reference

     Self reference

     Definition Classes

     Trees

218. trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi

     

     The API that all thises support

     The API that all thises support

     Definition Classes

     Trees

219. abstract class ThisExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax This(qual).

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

     qual.this

     The symbol of a This is the class to which the this refers. For instance in C.this, it would be C.

     Definition Classes

     Trees

220. abstract type ThisType >: Null <: Universe.ThisTypeApi with Universe.SingletonType

     

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

     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)

     Definition Classes

     Types

221. trait ThisTypeApi extends Universe.TypeApi

     

     The API that all this types support.

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

     Definition Classes

     Types

222. abstract class ThisTypeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.

     An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.

     Definition Classes

     Types

223. abstract type Throw >: Null <: Universe.ThrowApi with Universe.TermTree

     

     Throw expression

     Throw expression

     Definition Classes

     Trees

224. trait ThrowApi extends Universe.TermTreeApi

     

     The API that all tries support

     The API that all tries support

     Definition Classes

     Trees

225. abstract class ThrowExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Throw(expr).

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

     throw expr

     Definition Classes

     Trees

226. abstract class Transformer extends AnyRef

     

     A class that implement a default tree transformation strategy: breadth-first component-wise cloning.

     A class that implement a default tree transformation strategy: breadth-first component-wise cloning.

     Definition Classes

     Trees

227. class Traverser extends AnyRef

     

     A class that implement a default tree traversal strategy: breadth-first component-wise.

     A class that implement a default tree traversal strategy: breadth-first component-wise.

     Definition Classes

     Trees

228. abstract type Tree >: Null <: Universe.TreeApi

     

     The type of Scala abstract syntax trees.

     The type of Scala abstract syntax trees.

     Definition Classes

     Trees

229. trait TreeApi extends Product

     

     The API that all trees support.

     The API that all trees support. The main source of information about trees is the scala.reflect.api.Trees page.

     Definition Classes

     Trees

230. abstract type TreeCopier >: Null <: Universe.TreeCopierOps

     

     The type of standard (lazy) tree copiers.

     The type of standard (lazy) tree copiers.

     Definition Classes

     Trees

231. abstract class TreeCopierOps extends AnyRef

     

     The API of a tree copier.

     The API of a tree copier.

     Definition Classes

     Trees

232. trait TreeGen extends AnyRef

     

233. trait TreePrinter extends AnyRef

     
     Attributes

     protected

     Definition Classes

     Printers

234. abstract type Try >: Null <: Universe.TryApi with Universe.TermTree

     

     Try catch node

     Try catch node

     Definition Classes

     Trees

235. trait TryApi extends Universe.TermTreeApi

     

     The API that all tries support

     The API that all tries support

     Definition Classes

     Trees

236. abstract class TryExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Try(block, catches, finalizer).

     An extractor class to create and pattern match with syntax Try(block, catches, finalizer). This AST node corresponds to the following Scala code:

     try block catch { catches } finally finalizer

     If the finalizer is not present, the finalizer is set to EmptyTree.

     Definition Classes

     Trees

237. abstract type TypTree >: Null <: Universe.TypTreeApi with Universe.Tree

     

     A tree for a type.

     A tree for a type. Not all trees representing types are TypTrees; use isType to reliably identify types.

     Definition Classes

     Trees

238. trait TypTreeApi extends Universe.TreeApi

     

     The API that all typ trees support

     The API that all typ trees support

     Definition Classes

     Trees

239. abstract type Type >: Null <: Universe.TypeApi

     

     The type of Scala types, and also Scala type signatures.

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

     Definition Classes

     Types

240. abstract class TypeApi extends AnyRef

     

     The API of types.

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

     Definition Classes

     Types

241. abstract type TypeApply >: Null <: Universe.TypeApplyApi with Universe.GenericApply

     

     Explicit type application.

     Explicit type application.

     Definition Classes

     Trees

242. trait TypeApplyApi extends Universe.GenericApplyApi

     

     The API that all type applies support

     The API that all type applies support

     Definition Classes

     Trees

243. abstract class TypeApplyExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax TypeApply(fun, args).

     An extractor class to create and pattern match with syntax TypeApply(fun, args). This AST node corresponds to the following Scala code:

     fun[args]

     Should only be used with fun nodes which are terms, i.e. which have isTerm returning true. Otherwise AppliedTypeTree should be used instead.

     def foo[T] = ??? foo[Int] // represented as TypeApply(Ident(<foo>), List(TypeTree(<Int>)))

     List[Int] as in val x: List[Int] = ??? // represented as AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))

     Definition Classes

     Trees

244. abstract type TypeBounds >: Null <: Universe.TypeBoundsApi with Universe.Type

     

     The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types.

     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)

     Definition Classes

     Types

245. trait TypeBoundsApi extends Universe.TypeApi

     

     The API that all type bounds support.

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

     Definition Classes

     Types

246. abstract class TypeBoundsExtractor extends AnyRef

     

     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.

     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.

     Definition Classes

     Types

247. abstract type TypeBoundsTree >: Null <: Universe.TypeBoundsTreeApi with Universe.TypTree

     

     Type bounds tree node

     Type bounds tree node

     Definition Classes

     Trees

248. trait TypeBoundsTreeApi extends Universe.TypTreeApi

     

     The API that all type bound trees support

     The API that all type bound trees support

     Definition Classes

     Trees

249. abstract class TypeBoundsTreeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi).

     An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi). This AST node corresponds to the following Scala code:

     >: lo <: hi

     Definition Classes

     Trees

250. abstract type TypeDef >: Null <: Universe.TypeDefApi with Universe.MemberDef

     

     An abstract type, a type parameter, or a type alias.

     An abstract type, a type parameter, or a type alias. Eliminated by erasure.

     Definition Classes

     Trees

251. trait TypeDefApi extends Universe.MemberDefApi

     

     The API that all type defs support

     The API that all type defs support

     Definition Classes

     Trees

252. abstract class TypeDefExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax TypeDef(mods, name, tparams, rhs).

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

     mods type name[tparams] = rhs

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

     First usage illustrates TypeDefs representing type aliases and type parameters. Second usage illustrates TypeDefs representing abstract types, where lo and hi are both TypeBoundsTrees and Modifier.deferred is set in mods.

     Definition Classes

     Trees

253. abstract type TypeName >: Null <: TypeNameApi with Name

     

     The abstract type of names representing terms.

     The abstract type of names representing terms.

     Definition Classes

     Names

254. trait TypeNameApi extends AnyRef

     

     Has no special methods.

     Has no special methods. Is here to provides erased identity for TypeName.

     Definition Classes

     Names

255. abstract class TypeNameExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax TypeName(s).

     An extractor class to create and pattern match with syntax TypeName(s).

     Definition Classes

     Names

256. trait TypeNamesApi extends Universe.NamesApi

     

     Defines standard type names that can be accessed via the tpnme member.

     Defines standard type names that can be accessed via the tpnme member.

     Definition Classes

     StandardNames

257. abstract type TypeRef >: Null <: Universe.TypeRefApi with Universe.Type

     

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

     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)

     Definition Classes

     Types

258. trait TypeRefApi extends Universe.TypeApi

     

     The API that all type refs support.

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

     Definition Classes

     Types

259. abstract class TypeRefExtractor extends AnyRef

     

     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.

     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.

     Definition Classes

     Types

260. abstract type TypeSymbol >: Null <: Universe.TypeSymbolApi with Universe.Symbol

     

     The type of type symbols representing type, class, and trait declarations, as well as type parameters.

     The type of type symbols representing type, class, and trait declarations, as well as type parameters.

     Definition Classes

     Symbols

261. trait TypeSymbolApi extends Universe.SymbolApi

     

     The API of type symbols.

     The API of type symbols. The main source of information about symbols is the Symbols page.

     Class Symbol defines isXXX test methods such as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, Nil or other empty values.

     Definition Classes

     Symbols

262. trait TypeTag[T] extends Universe.WeakTypeTag[T] with Equals with Serializable

     

     A TypeTag is a scala.reflect.api.TypeTags#WeakTypeTag with the additional static guarantee that all type references are concrete, i.e.

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

     Definition Classes

     TypeTags

     Annotations

     @implicitNotFound( "No TypeTag available for ${T}" )

     See also

     scala.reflect.api.TypeTags

263. abstract type TypeTree >: Null <: Universe.TypeTreeApi with Universe.TypTree

     

     A synthetic tree holding an arbitrary type.

     A synthetic tree holding an arbitrary type. Not to be confused with with TypTree, the trait for trees that are only used for type trees. TypeTree's are inserted in several places, but most notably in RefCheck, where the arbitrary type trees are all replaced by TypeTree's.

     Definition Classes

     Trees

264. trait TypeTreeApi extends Universe.TypTreeApi

     

     The API that all type trees support

     The API that all type trees support

     Definition Classes

     Trees

265. abstract class TypeTreeExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax TypeTree().

     An extractor class to create and pattern match with syntax TypeTree(). This AST node does not have direct correspondence to Scala code, and is emitted by everywhere when we want to wrap a Type in a Tree.

     Definition Classes

     Trees

266. abstract type Typed >: Null <: Universe.TypedApi with Universe.TermTree

     

     Type annotation, eliminated by compiler phase cleanup

     Type annotation, eliminated by compiler phase cleanup

     Definition Classes

     Trees

267. trait TypedApi extends Universe.TermTreeApi

     

     The API that all typeds support

     The API that all typeds support

     Definition Classes

     Trees

268. abstract class TypedExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax Typed(expr, tpt).

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

     expr: tpt

     Definition Classes

     Trees

269. abstract type UnApply >: Null <: Universe.UnApplyApi with Universe.TermTree

     

     Used to represent unapply methods in pattern matching.

     Used to represent unapply methods in pattern matching.

     For example:

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

     Is represented as:

     Match(
       Literal(Constant(2)),
       List(
         CaseDef(
           UnApply(
             // a dummy node that carries the type of unapplication to patmat
             // the  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("")))),
             // arguments of the unapply => nothing synthetic here
             List(Bind(TermName("x"), Ident(nme.WILDCARD)))),
           EmptyTree,
           Ident(TermName("x")))))

     Introduced by typer. Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

     Definition Classes

     Trees

270. trait UnApplyApi extends Universe.TermTreeApi

     

     The API that all unapplies support

     The API that all unapplies support

     Definition Classes

     Trees

271. abstract class UnApplyExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax UnApply(fun, args).

     An extractor class to create and pattern match with syntax UnApply(fun, args). This AST node does not have direct correspondence to Scala code, and is introduced when typechecking pattern matches and try blocks.

     Definition Classes

     Trees

272. trait Unliftable[T] extends AnyRef

     

     A type class that defines a way to extract instance of T from a Tree.

     A type class that defines a way to extract instance of T from a Tree.

     Definition Classes

     Liftables

     See also

     http://docs.scala-lang.org/overviews/quasiquotes/unlifting.html

273. abstract type ValDef >: Null <: Universe.ValDefApi with Universe.ValOrDefDef

     

     Broadly speaking, a value definition.

     Broadly speaking, a value definition. All these are encoded as ValDefs:

     • immutable values, e.g. "val x"
     • mutable values, e.g. "var x" - the MUTABLE flag set in mods
     • lazy values, e.g. "lazy val x" - the LAZY flag set in mods
     • method parameters, see vparamss in scala.reflect.api.Trees#DefDef - the PARAM flag is set in mods
     • explicit self-types, e.g. class A { self: Bar => }

     Definition Classes

     Trees

274. trait ValDefApi extends Universe.ValOrDefDefApi

     

     The API that all val defs support

     The API that all val defs support

     Definition Classes

     Trees

275. abstract class ValDefExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs).

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

     mods val name: tpt = rhs

     mods var name: tpt = rhs

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

     self: Bar => // self-types

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

     Definition Classes

     Trees

276. abstract type ValOrDefDef >: Null <: Universe.ValOrDefDefApi with Universe.MemberDef

     

     A common base class for ValDefs and DefDefs.

     A common base class for ValDefs and DefDefs.

     Definition Classes

     Trees

277. trait ValOrDefDefApi extends Universe.MemberDefApi

     

     The API that all val defs and def defs support

     The API that all val defs and def defs support

     Definition Classes

     Trees

278. trait WeakTypeTag[T] extends Equals with Serializable

     

     If an implicit value of type WeakTypeTag[T] is required, the compiler will create one, and the reflective representation of T can be accessed via the tpe field.

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

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

     Definition Classes

     TypeTags

     Annotations

     @implicitNotFound( "No WeakTypeTag available for ${T}" )

     See also

     scala.reflect.api.TypeTags

279. abstract type ArrayArgument >: Null <: Universe.ArrayArgumentApi with Universe.JavaArgument

     

     An array argument to a Java annotation as in @Target(value={TYPE,FIELD,METHOD,PARAMETER})

     An array argument to a Java annotation as in @Target(value={TYPE,FIELD,METHOD,PARAMETER})

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

280. trait ArrayArgumentApi extends AnyRef

     

     API of ArrayArgument instances.

     API of ArrayArgument instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

281. abstract class ArrayArgumentExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax ArrayArgument(args) where args is the argument array.

     An extractor class to create and pattern match with syntax ArrayArgument(args) where args is the argument array.

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

282. type BuildApi = ReificationSupportApi

     

     Definition Classes

     Internals

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use internal.ReificationSupportApi instead

283. abstract type CompilationUnit <: CompilationUnitContextApi

     

     The type of compilation units.

     The type of compilation units.

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

     scala.reflect.macros.Enclosures

284. trait CompilationUnitContextApi extends AnyRef

     

     Compilation unit describes a unit of work of the compilation run.

     Compilation unit describes a unit of work of the compilation run. It provides such information as file name, textual representation of the unit and the underlying AST.

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

     scala.reflect.macros.Enclosures

285. abstract type JavaArgument >: Null <: Universe.JavaArgumentApi

     

     A Java annotation argument

     A Java annotation argument

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

286. trait JavaArgumentApi extends AnyRef

     

     Has no special methods.

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

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

287. abstract type LiteralArgument >: Null <: Universe.LiteralArgumentApi with Universe.JavaArgument

     

     A literal argument to a Java annotation as "Use X instead" in @Deprecated("Use X instead")

     A literal argument to a Java annotation as "Use X instead" in @Deprecated("Use X instead")

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

288. trait LiteralArgumentApi extends AnyRef

     

     The API of LiteralArgument instances.

     The API of LiteralArgument instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

289. abstract class LiteralArgumentExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax LiteralArgument(value) where value is the constant argument.

     An extractor class to create and pattern match with syntax LiteralArgument(value) where value is the constant argument.

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

290. type ModifiersCreator = ModifiersExtractor

     

     Definition Classes

     Trees

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use ModifiersExtractor instead

291. abstract type NestedArgument >: Null <: Universe.NestedArgumentApi with Universe.JavaArgument

     

     A nested annotation argument to a Java annotation as @Nested in @Outer(@Nested).

     A nested annotation argument to a Java annotation as @Nested in @Outer(@Nested).

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

292. trait NestedArgumentApi extends AnyRef

     

     API of NestedArgument instances.

     API of NestedArgument instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

293. abstract class NestedArgumentExtractor extends AnyRef

     

     An extractor class to create and pattern match with syntax NestedArgument(annotation) where annotation is the nested annotation.

     An extractor class to create and pattern match with syntax NestedArgument(annotation) where annotation is the nested annotation.

     Definition Classes

     Annotations

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use Annotation.tree to inspect annotation arguments

294. abstract type Run <: RunContextApi

     

     The type of compilation runs.

     The type of compilation runs.

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

     scala.reflect.macros.Enclosures

295. trait RunContextApi extends AnyRef

     

     Compilation run uniquely identifies current invocation of the compiler (e.g.

     Compilation run uniquely identifies current invocation of the compiler (e.g. can be used to implement per-run caches for macros) and provides access to units of work of the invocation (currently processed unit of work and the list of all units).

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

     scala.reflect.macros.Enclosures