Class

scala.reflect.macros

Universe

Related Doc: package macros

Permalink

abstract class Universe extends api.Universe

EXPERIMENTAL

The refinement of scala.reflect.api.Universe for the use by macro writers.

This universe provides mutability for reflection artifacts (e.g. macros can change types of compiler trees, add annotation to symbols representing definitions, etc) and exposes some internal compiler functionality such as Symbol.deSkolemize or Tree.attachments.

Source
Universe.scala
Linear Supertypes
Type Hierarchy
Content Hierarchy
Universe.TypeSymbolUniverse.ClassSymbolUniverse.FreeTypeSymbolUniverse.TermSymbolUniverse.MethodSymbolUniverse.ModuleSymbolUniverse.FreeTermSymbolUniverse.SingletonTypeUniverse.ThisTypeUniverse.SingleTypeUniverse.SuperTypeUniverse.ConstantTypeUniverse.TypeRefUniverse.CompoundTypeUniverse.RefinedTypeUniverse.ClassInfoTypeUniverse.MethodTypeUniverse.NullaryMethodTypeUniverse.PolyTypeUniverse.ExistentialTypeUniverse.AnnotatedTypeUniverse.TypeBoundsUniverse.BoundedWildcardTypeUniverse.MemberScopeUniverse.TermTreeUniverse.LabelDefUniverse.BlockUniverse.AlternativeUniverse.StarUniverse.UnApplyUniverse.FunctionUniverse.AssignUniverse.AssignOrNamedArgUniverse.IfUniverse.MatchUniverse.ReturnUniverse.TryUniverse.ThrowUniverse.NewUniverse.TypedUniverse.GenericApplyUniverse.SuperUniverse.ThisUniverse.LiteralUniverse.ReferenceToBoxedUniverse.TypTreeUniverse.SingletonTypeTreeUniverse.SelectFromTypeTreeUniverse.CompoundTypeTreeUniverse.AppliedTypeTreeUniverse.TypeBoundsTreeUniverse.ExistentialTypeTreeUniverse.TypeTreeUniverse.SymTreeUniverse.RefTreeUniverse.DefTreeUniverse.ImportUniverse.TemplateUniverse.NameTreeUniverse.SelectUniverse.IdentUniverse.MemberDefUniverse.BindUniverse.PackageDefUniverse.ImplDefUniverse.ValOrDefDefUniverse.TypeDefUniverse.ClassDefUniverse.ModuleDefUniverse.ValDefUniverse.DefDefUniverse.CaseDefUniverse.TypeApplyUniverse.ApplyUniverse.AnnotatedUniverse.TreeCopierUniverse.LiteralArgumentUniverse.ArrayArgumentUniverse.NestedArgumentUniverse.TypeTag[T]Universe.ModuleMirrorUniverse.ClassMirrorUniverse.RuntimeMirrorLiftableUnliftableUniverse.SymbolUniverse.TypeUniverse.ScopeUniverse.TreeUniverse.TreeCopierOpsUniverse.JavaArgumentUniverse.WeakTypeTag[T]Universe.TemplateMirrorUniverse.ReflectiveMirrorUniverse.StandardLiftableInstancesUniverse.StandardUnliftableInstances
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. Universe
  2. Universe
  3. Internals
  4. Quasiquotes
  5. Liftables
  6. Printers
  7. Mirrors
  8. StandardLiftables
  9. StandardNames
  10. StandardDefinitions
  11. ImplicitTags
  12. TypeTags
  13. Exprs
  14. Positions
  15. Annotations
  16. Constants
  17. Trees
  18. Names
  19. Scopes
  20. FlagSets
  21. Types
  22. Symbols
  23. AnyRef
  24. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Universe()

    Permalink

Type Members

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

    Permalink

    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

    Permalink

    The API that all alternatives support

    The API that all alternatives support

    Definition Classes
    Trees
  3. abstract class AlternativeExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all annotateds support

    The API that all annotateds support

    Definition Classes
    Trees
  6. abstract class AnnotatedExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Information about an annotation.

    Information about an annotation.

    Definition Classes
    Annotations
  11. trait AnnotationApi extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

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

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

    Definition Classes
    Trees
  14. trait AppliedTypeTreeApi extends Universe.TypTreeApi

    Permalink

    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

    Permalink

    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

    Permalink

    Value application

    Value application

    Definition Classes
    Trees
  17. trait ApplyApi extends Universe.GenericApplyApi

    Permalink

    The API that all applies support

    The API that all applies support

    Definition Classes
    Trees
  18. abstract class ApplyExtractor extends AnyRef

    Permalink

    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

    Permalink

    Assignment

    Assignment

    Definition Classes
    Trees
  20. trait AssignApi extends Universe.TermTreeApi

    Permalink

    The API that all assigns support

    The API that all assigns support

    Definition Classes
    Trees
  21. abstract class AssignExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all assigns support

    The API that all assigns support

    Definition Classes
    Trees
  24. abstract class AssignOrNamedArgExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all binds support

    The API that all binds support

    Definition Classes
    Trees
  27. abstract class BindExtractor extends AnyRef

    Permalink

    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

    Permalink

    Block of expressions (semicolon separated expressions)

    Block of expressions (semicolon separated expressions)

    Definition Classes
    Trees
  29. trait BlockApi extends Universe.TermTreeApi

    Permalink

    The API that all blocks support

    The API that all blocks support

    Definition Classes
    Trees
  30. abstract class BlockExtractor extends AnyRef

    Permalink

    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

    Permalink

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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all case defs support

    The API that all case defs support

    Definition Classes
    Trees
  37. abstract class CaseDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    A class definition.

    A class definition.

    Definition Classes
    Trees
  39. trait ClassDefApi extends Universe.ImplDefApi

    Permalink

    The API that all class defs support

    The API that all class defs support

    Definition Classes
    Trees
  40. abstract class ClassDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Definition Classes
    UniverseInternals
  48. trait CompatApi extends AnyRef

    Permalink

    Definition Classes
    Internals
    See also

    compat

  49. class CompatToken extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Intersection type <parent1> with ...

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

    Definition Classes
    Trees
  53. trait CompoundTypeTreeApi extends Universe.TypTreeApi

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API of Constant instances.

    The API of Constant instances.

    Definition Classes
    Constants
  57. abstract class ConstantExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    A method or macro definition.

    A method or macro definition.

    Definition Classes
    Trees
  62. trait DefDefApi extends Universe.ValOrDefDefApi

    Permalink

    The API that all def defs support

    The API that all def defs support

    Definition Classes
    Trees
  63. abstract class DefDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all def trees support

    The API that all def trees support

    Definition Classes
    Trees
  66. trait DefinitionsApi extends Universe.StandardTypes

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Existential type tree node

    Existential type tree node

    Definition Classes
    Trees
  71. trait ExistentialTypeTreeApi extends Universe.TypTreeApi

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all functions support

    The API that all functions support

    Definition Classes
    Trees
  84. abstract class FunctionExtractor extends AnyRef

    Permalink

    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

    Permalink

    Common base class for Apply and TypeApply.

    Common base class for Apply and TypeApply.

    Definition Classes
    Trees
  86. trait GenericApplyApi extends Universe.TermTreeApi

    Permalink

    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

    Permalink

    A reference to identifier name.

    A reference to identifier name.

    Definition Classes
    Trees
  88. trait IdentApi extends Universe.RefTreeApi

    Permalink

    The API that all idents support

    The API that all idents support

    Definition Classes
    Trees
  89. abstract class IdentExtractor extends AnyRef

    Permalink

    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

    Permalink

    Conditional expression

    Conditional expression

    Definition Classes
    Trees
  91. trait IfApi extends Universe.TermTreeApi

    Permalink

    The API that all ifs support

    The API that all ifs support

    Definition Classes
    Trees
  92. abstract class IfExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Import clause

    Import clause

    Definition Classes
    Trees
  96. trait ImportApi extends Universe.SymTreeApi

    Permalink

    The API that all imports support

    The API that all imports support

    Definition Classes
    Trees
  97. abstract class ImportExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all import selectors support

    The API that all import selectors support

    Definition Classes
    Trees
  100. abstract class ImportSelectorExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Definition Classes
    UniverseInternals
  104. trait InternalApi extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all label defs support

    The API that all label defs support

    Definition Classes
    Trees
  107. abstract class LabelDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    Literal

    Literal

    Definition Classes
    Trees
  110. trait LiteralApi extends Universe.TermTreeApi

    Permalink

    The API that all literals support

    The API that all literals support

    Definition Classes
    Trees
  111. abstract class LiteralExtractor extends AnyRef

    Permalink

    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

    Permalink

    See also

    compat

  113. trait MacroInternalApi extends InternalApi

    Permalink

    <invalid inheritdoc annotation>

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

    Permalink

    - 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

    Permalink

    The API that all matches support

    The API that all matches support

    Definition Classes
    Trees
  116. abstract class MatchExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all member scopes support

    The API that all member scopes support

    Definition Classes
    Scopes
  121. trait MethodMirror extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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]

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all Modifiers support

    The API that all Modifiers support

    Definition Classes
    Trees
  130. abstract class ModifiersExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all module defs support

    The API that all module defs support

    Definition Classes
    Trees
  133. abstract class ModuleDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The abstract type of names.

    The abstract type of names.

    Definition Classes
    Names
  138. abstract class NameApi extends AnyRef

    Permalink

    The API of Name instances.

    The API of Name instances.

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

    Permalink

    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

    Permalink

    The API that all name trees support

    The API that all name trees support

    Definition Classes
    Trees
  141. trait NamesApi extends AnyRef

    Permalink

    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

    Permalink

    Object instantiation

    Object instantiation

    Definition Classes
    Trees
  143. trait NewApi extends Universe.TermTreeApi

    Permalink

    The API that all news support

    The API that all news support

    Definition Classes
    Trees
  144. abstract class NewExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    A packaging, such as package pid { stats }

    A packaging, such as package pid { stats }

    Definition Classes
    Trees
  149. trait PackageDefApi extends Universe.MemberDefApi

    Permalink

    The API that all package defs support

    The API that all package defs support

    Definition Classes
    Trees
  150. abstract class PackageDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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 }

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all ref trees support

    The API that all ref trees support

    Definition Classes
    Trees
  158. abstract class RefTreeExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all references support

    The API that all references support

    Definition Classes
    Internals
  161. abstract class ReferenceToBoxedExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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]

    Permalink

    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

    Permalink

    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

    Permalink

    Return expression

    Return expression

    Definition Classes
    Trees
  168. trait ReturnApi extends Universe.TermTreeApi

    Permalink

    The API that all returns support

    The API that all returns support

    Definition Classes
    Trees
  169. abstract class ReturnExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The base type of all scopes.

    The base type of all scopes.

    Definition Classes
    Scopes
  174. trait ScopeApi extends Iterable[Universe.Symbol]

    Permalink

    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

    Permalink

    A member selection <qualifier> .

    A member selection <qualifier> . <name>

    Definition Classes
    Trees
  176. trait SelectApi extends Universe.RefTreeApi

    Permalink

    The API that all selects support

    The API that all selects support

    Definition Classes
    Trees
  177. abstract class SelectExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Singleton type, eliminated by RefCheck

    Singleton type, eliminated by RefCheck

    Definition Classes
    Trees
  187. trait SingletonTypeTreeApi extends Universe.TypTreeApi

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    StandardLiftables
  190. trait StandardTypes extends AnyRef

    Permalink

    Defines standard types.

    Defines standard types.

    Definition Classes
    StandardDefinitions
  191. trait StandardUnliftableInstances extends AnyRef

    Permalink
    Definition Classes
    StandardLiftables
  192. abstract type Star >: Null <: Universe.StarApi with Universe.TermTree

    Permalink

    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

    Permalink

    The API that all stars support

    The API that all stars support

    Definition Classes
    Trees
  194. abstract class StarExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all supers support

    The API that all supers support

    Definition Classes
    Trees
  197. abstract class SuperExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all sym trees support

    The API that all sym trees support

    Definition Classes
    Trees
  203. abstract type Symbol >: Null <: Universe.SymbolApi

    Permalink

    The type of symbols representing declarations.

    The type of symbols representing declarations.

    Definition Classes
    Symbols
  204. trait SymbolApi extends AnyRef

    Permalink

    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

    Permalink

    Instantiation template of a class or trait

    Instantiation template of a class or trait

    Definition Classes
    Trees
  206. trait TemplateApi extends Universe.SymTreeApi

    Permalink

    The API that all templates support

    The API that all templates support

    Definition Classes
    Trees
  207. abstract class TemplateExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The abstract type of names representing types.

    The abstract type of names representing types.

    Definition Classes
    Names
  210. trait TermNameApi extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Self reference

    Self reference

    Definition Classes
    Trees
  218. trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi

    Permalink

    The API that all thises support

    The API that all thises support

    Definition Classes
    Trees
  219. abstract class ThisExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Throw expression

    Throw expression

    Definition Classes
    Trees
  224. trait ThrowApi extends Universe.TermTreeApi

    Permalink

    The API that all tries support

    The API that all tries support

    Definition Classes
    Trees
  225. abstract class ThrowExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The type of Scala abstract syntax trees.

    The type of Scala abstract syntax trees.

    Definition Classes
    Trees
  229. trait TreeApi extends Product

    Permalink

    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

    Permalink

    The type of standard (lazy) tree copiers.

    The type of standard (lazy) tree copiers.

    Definition Classes
    Trees
  231. abstract class TreeCopierOps extends AnyRef

    Permalink

    The API of a tree copier.

    The API of a tree copier.

    Definition Classes
    Trees
  232. trait TreeGen extends AnyRef

    Permalink

  233. trait TreePrinter extends AnyRef

    Permalink

    Attributes
    protected
    Definition Classes
    Printers
  234. abstract type Try >: Null <: Universe.TryApi with Universe.TermTree

    Permalink

    Try catch node

    Try catch node

    Definition Classes
    Trees
  235. trait TryApi extends Universe.TermTreeApi

    Permalink

    The API that all tries support

    The API that all tries support

    Definition Classes
    Trees
  236. abstract class TryExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all typ trees support

    The API that all typ trees support

    Definition Classes
    Trees
  239. abstract type Type >: Null <: Universe.TypeApi

    Permalink

    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

    Permalink

    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

    Permalink

    Explicit type application.

    Explicit type application.

    Definition Classes
    Trees
  242. trait TypeApplyApi extends Universe.GenericApplyApi

    Permalink

    The API that all type applies support

    The API that all type applies support

    Definition Classes
    Trees
  243. abstract class TypeApplyExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Type bounds tree node

    Type bounds tree node

    Definition Classes
    Trees
  248. trait TypeBoundsTreeApi extends Universe.TypTreeApi

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all type defs support

    The API that all type defs support

    Definition Classes
    Trees
  252. abstract class TypeDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    The abstract type of names representing terms.

    The abstract type of names representing terms.

    Definition Classes
    Names
  254. trait TypeNameApi extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all type trees support

    The API that all type trees support

    Definition Classes
    Trees
  265. abstract class TypeTreeExtractor extends AnyRef

    Permalink

    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

    Permalink

    Type annotation, eliminated by compiler phase cleanup

    Type annotation, eliminated by compiler phase cleanup

    Definition Classes
    Trees
  267. trait TypedApi extends Universe.TermTreeApi

    Permalink

    The API that all typeds support

    The API that all typeds support

    Definition Classes
    Trees
  268. abstract class TypedExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all unapplies support

    The API that all unapplies support

    Definition Classes
    Trees
  271. abstract class UnApplyExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    The API that all val defs support

    The API that all val defs support

    Definition Classes
    Trees
  275. abstract class ValDefExtractor extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    Internals
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use internal.ReificationSupportApi instead

  283. abstract type CompilationUnit <: CompilationUnitContextApi

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use ModifiersExtractor instead

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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

Abstract Value Members

  1. abstract val Alternative: AlternativeExtractor

    Permalink

    The constructor/extractor for Alternative instances.

    The constructor/extractor for Alternative instances.

    Definition Classes
    Trees
  2. implicit abstract val AlternativeTag: ClassTag[Alternative]

    Permalink
    Definition Classes
    ImplicitTags
  3. abstract val Annotated: AnnotatedExtractor

    Permalink

    The constructor/extractor for Annotated instances.

    The constructor/extractor for Annotated instances.

    Definition Classes
    Trees
  4. implicit abstract val AnnotatedTag: ClassTag[Annotated]

    Permalink
    Definition Classes
    ImplicitTags
  5. abstract val AnnotatedType: AnnotatedTypeExtractor

    Permalink

    The constructor/extractor for AnnotatedType instances.

    The constructor/extractor for AnnotatedType instances.

    Definition Classes
    Types
  6. implicit abstract val AnnotatedTypeTag: ClassTag[AnnotatedType]

    Permalink
    Definition Classes
    ImplicitTags
  7. abstract val Annotation: AnnotationExtractor

    Permalink

    The constructor/extractor for Annotation instances.

    The constructor/extractor for Annotation instances.

    Definition Classes
    Annotations
  8. implicit abstract val AnnotationTag: ClassTag[Annotation]

    Permalink
    Definition Classes
    ImplicitTags
  9. abstract val AppliedTypeTree: AppliedTypeTreeExtractor

    Permalink

    The constructor/extractor for AppliedTypeTree instances.

    The constructor/extractor for AppliedTypeTree instances.

    Definition Classes
    Trees
  10. implicit abstract val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]

    Permalink
    Definition Classes
    ImplicitTags
  11. abstract val Apply: ApplyExtractor

    Permalink

    The constructor/extractor for Apply instances.

    The constructor/extractor for Apply instances.

    Definition Classes
    Trees
  12. implicit abstract val ApplyTag: ClassTag[Apply]

    Permalink
    Definition Classes
    ImplicitTags
  13. implicit abstract val ArrayArgumentTag: ClassTag[ArrayArgument]

    Permalink
    Definition Classes
    ImplicitTags
  14. abstract val Assign: AssignExtractor

    Permalink

    The constructor/extractor for Assign instances.

    The constructor/extractor for Assign instances.

    Definition Classes
    Trees
  15. abstract val AssignOrNamedArg: AssignOrNamedArgExtractor

    Permalink

    The constructor/extractor for AssignOrNamedArg instances.

    The constructor/extractor for AssignOrNamedArg instances.

    Definition Classes
    Trees
  16. implicit abstract val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

    Permalink
    Definition Classes
    ImplicitTags
  17. implicit abstract val AssignTag: ClassTag[Assign]

    Permalink
    Definition Classes
    ImplicitTags
  18. abstract val Bind: BindExtractor

    Permalink

    The constructor/extractor for Bind instances.

    The constructor/extractor for Bind instances.

    Definition Classes
    Trees
  19. implicit abstract val BindTag: ClassTag[Bind]

    Permalink
    Definition Classes
    ImplicitTags
  20. abstract val Block: BlockExtractor

    Permalink

    The constructor/extractor for Block instances.

    The constructor/extractor for Block instances.

    Definition Classes
    Trees
  21. implicit abstract val BlockTag: ClassTag[Block]

    Permalink
    Definition Classes
    ImplicitTags
  22. abstract val BoundedWildcardType: BoundedWildcardTypeExtractor

    Permalink

    The constructor/extractor for BoundedWildcardType instances.

    The constructor/extractor for BoundedWildcardType instances.

    Definition Classes
    Types
  23. implicit abstract val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]

    Permalink
    Definition Classes
    ImplicitTags
  24. abstract val CaseDef: CaseDefExtractor

    Permalink

    The constructor/extractor for CaseDef instances.

    The constructor/extractor for CaseDef instances.

    Definition Classes
    Trees
  25. implicit abstract val CaseDefTag: ClassTag[CaseDef]

    Permalink
    Definition Classes
    ImplicitTags
  26. abstract val ClassDef: ClassDefExtractor

    Permalink

    The constructor/extractor for ClassDef instances.

    The constructor/extractor for ClassDef instances.

    Definition Classes
    Trees
  27. implicit abstract val ClassDefTag: ClassTag[ClassDef]

    Permalink
    Definition Classes
    ImplicitTags
  28. abstract val ClassInfoType: ClassInfoTypeExtractor

    Permalink

    The constructor/extractor for ClassInfoType instances.

    The constructor/extractor for ClassInfoType instances.

    Definition Classes
    Types
  29. implicit abstract val ClassInfoTypeTag: ClassTag[ClassInfoType]

    Permalink
    Definition Classes
    ImplicitTags
  30. implicit abstract val ClassSymbolTag: ClassTag[ClassSymbol]

    Permalink
    Definition Classes
    ImplicitTags
  31. implicit abstract val CompoundTypeTag: ClassTag[CompoundType]

    Permalink
    Definition Classes
    ImplicitTags
  32. abstract val CompoundTypeTree: CompoundTypeTreeExtractor

    Permalink

    The constructor/extractor for CompoundTypeTree instances.

    The constructor/extractor for CompoundTypeTree instances.

    Definition Classes
    Trees
  33. implicit abstract val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]

    Permalink
    Definition Classes
    ImplicitTags
  34. abstract val Constant: ConstantExtractor

    Permalink

    The constructor/extractor for Constant instances.

    The constructor/extractor for Constant instances.

    Definition Classes
    Constants
  35. implicit abstract val ConstantTag: ClassTag[Constant]

    Permalink
    Definition Classes
    ImplicitTags
  36. abstract val ConstantType: ConstantTypeExtractor

    Permalink

    The constructor/extractor for ConstantType instances.

    The constructor/extractor for ConstantType instances.

    Definition Classes
    Types
  37. implicit abstract val ConstantTypeTag: ClassTag[ConstantType]

    Permalink
    Definition Classes
    ImplicitTags
  38. abstract val DefDef: DefDefExtractor

    Permalink

    The constructor/extractor for DefDef instances.

    The constructor/extractor for DefDef instances.

    Definition Classes
    Trees
  39. implicit abstract val DefDefTag: ClassTag[DefDef]

    Permalink
    Definition Classes
    ImplicitTags
  40. implicit abstract val DefTreeTag: ClassTag[DefTree]

    Permalink
    Definition Classes
    ImplicitTags
  41. abstract val EmptyTree: Tree

    Permalink

    The empty tree

    The empty tree

    Definition Classes
    Trees
  42. abstract val ExistentialType: ExistentialTypeExtractor

    Permalink

    The constructor/extractor for ExistentialType instances.

    The constructor/extractor for ExistentialType instances.

    Definition Classes
    Types
  43. implicit abstract val ExistentialTypeTag: ClassTag[ExistentialType]

    Permalink
    Definition Classes
    ImplicitTags
  44. abstract val ExistentialTypeTree: ExistentialTypeTreeExtractor

    Permalink

    The constructor/extractor for ExistentialTypeTree instances.

    The constructor/extractor for ExistentialTypeTree instances.

    Definition Classes
    Trees
  45. implicit abstract val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]

    Permalink
    Definition Classes
    ImplicitTags
  46. abstract val Flag: FlagValues

    Permalink

    A module that contains all possible values that can constitute flag sets.

    A module that contains all possible values that can constitute flag sets.

    Definition Classes
    FlagSets
  47. implicit abstract val FlagSetTag: ClassTag[FlagSet]

    Permalink
    Definition Classes
    ImplicitTags
  48. implicit abstract val FreeTermSymbolTag: ClassTag[FreeTermSymbol]

    Permalink

    Tag that preserves the identity of FreeTermSymbol in the face of erasure.

    Tag that preserves the identity of FreeTermSymbol in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.

    Definition Classes
    Internals
  49. implicit abstract val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]

    Permalink

    Tag that preserves the identity of FreeTermSymbol in the face of erasure.

    Tag that preserves the identity of FreeTermSymbol in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.

    Definition Classes
    Internals
  50. abstract val Function: FunctionExtractor

    Permalink

    The constructor/extractor for Function instances.

    The constructor/extractor for Function instances.

    Definition Classes
    Trees
  51. implicit abstract val FunctionTag: ClassTag[Function]

    Permalink
    Definition Classes
    ImplicitTags
  52. implicit abstract val GenericApplyTag: ClassTag[GenericApply]

    Permalink
    Definition Classes
    ImplicitTags
  53. abstract def Ident(sym: Symbol): Ident

    Permalink

    A factory method for Ident nodes.

    A factory method for Ident nodes.

    Definition Classes
    Trees
  54. abstract val Ident: IdentExtractor

    Permalink

    The constructor/extractor for Ident instances.

    The constructor/extractor for Ident instances.

    Definition Classes
    Trees
  55. implicit abstract val IdentTag: ClassTag[Ident]

    Permalink
    Definition Classes
    ImplicitTags
  56. abstract val If: IfExtractor

    Permalink

    The constructor/extractor for If instances.

    The constructor/extractor for If instances.

    Definition Classes
    Trees
  57. implicit abstract val IfTag: ClassTag[If]

    Permalink
    Definition Classes
    ImplicitTags
  58. implicit abstract val ImplDefTag: ClassTag[ImplDef]

    Permalink
    Definition Classes
    ImplicitTags
  59. abstract val Import: ImportExtractor

    Permalink

    The constructor/extractor for Import instances.

    The constructor/extractor for Import instances.

    Definition Classes
    Trees
  60. abstract val ImportSelector: ImportSelectorExtractor

    Permalink

    The constructor/extractor for ImportSelector instances.

    The constructor/extractor for ImportSelector instances.

    Definition Classes
    Trees
  61. implicit abstract val ImportSelectorTag: ClassTag[ImportSelector]

    Permalink
    Definition Classes
    ImplicitTags
  62. implicit abstract val ImportTag: ClassTag[Import]

    Permalink
    Definition Classes
    ImplicitTags
  63. implicit abstract val JavaArgumentTag: ClassTag[JavaArgument]

    Permalink
    Definition Classes
    ImplicitTags
  64. abstract val LabelDef: LabelDefExtractor

    Permalink

    The constructor/extractor for LabelDef instances.

    The constructor/extractor for LabelDef instances.

    Definition Classes
    Trees
  65. implicit abstract val LabelDefTag: ClassTag[LabelDef]

    Permalink
    Definition Classes
    ImplicitTags
  66. abstract val Literal: LiteralExtractor

    Permalink

    The constructor/extractor for Literal instances.

    The constructor/extractor for Literal instances.

    Definition Classes
    Trees
  67. implicit abstract val LiteralArgumentTag: ClassTag[LiteralArgument]

    Permalink
    Definition Classes
    ImplicitTags
  68. implicit abstract val LiteralTag: ClassTag[Literal]

    Permalink
    Definition Classes
    ImplicitTags
  69. abstract val Match: MatchExtractor

    Permalink

    The constructor/extractor for Match instances.

    The constructor/extractor for Match instances.

    Definition Classes
    Trees
  70. implicit abstract val MatchTag: ClassTag[Match]

    Permalink
    Definition Classes
    ImplicitTags
  71. implicit abstract val MemberDefTag: ClassTag[MemberDef]

    Permalink
    Definition Classes
    ImplicitTags
  72. implicit abstract val MemberScopeTag: ClassTag[MemberScope]

    Permalink
    Definition Classes
    ImplicitTags
  73. implicit abstract val MethodSymbolTag: ClassTag[MethodSymbol]

    Permalink
    Definition Classes
    ImplicitTags
  74. abstract val MethodType: MethodTypeExtractor

    Permalink

    The constructor/extractor for MethodType instances.

    The constructor/extractor for MethodType instances.

    Definition Classes
    Types
  75. implicit abstract val MethodTypeTag: ClassTag[MethodType]

    Permalink
    Definition Classes
    ImplicitTags
  76. implicit abstract val MirrorTag: ClassTag[Mirror]

    Permalink
    Definition Classes
    ImplicitTags
  77. abstract val Modifiers: ModifiersExtractor

    Permalink

    The constructor/extractor for Modifiers instances.

    The constructor/extractor for Modifiers instances.

    Definition Classes
    Trees
  78. implicit abstract val ModifiersTag: ClassTag[Modifiers]

    Permalink
    Definition Classes
    ImplicitTags
  79. abstract val ModuleDef: ModuleDefExtractor

    Permalink

    The constructor/extractor for ModuleDef instances.

    The constructor/extractor for ModuleDef instances.

    Definition Classes
    Trees
  80. implicit abstract val ModuleDefTag: ClassTag[ModuleDef]

    Permalink
    Definition Classes
    ImplicitTags
  81. implicit abstract val ModuleSymbolTag: ClassTag[ModuleSymbol]

    Permalink
    Definition Classes
    ImplicitTags
  82. implicit abstract val NameTag: ClassTag[Name]

    Permalink
    Definition Classes
    ImplicitTags
  83. implicit abstract val NameTreeTag: ClassTag[NameTree]

    Permalink
    Definition Classes
    ImplicitTags
  84. implicit abstract val NestedArgumentTag: ClassTag[NestedArgument]

    Permalink
    Definition Classes
    ImplicitTags
  85. abstract val New: NewExtractor

    Permalink

    The constructor/extractor for New instances.

    The constructor/extractor for New instances.

    Definition Classes
    Trees
  86. implicit abstract val NewTag: ClassTag[New]

    Permalink
    Definition Classes
    ImplicitTags
  87. abstract val NoFlags: FlagSet

    Permalink

    The empty set of flags

    The empty set of flags

    Definition Classes
    FlagSets
  88. abstract val NoPosition: Position

    Permalink

    A special "missing" position.

    A special "missing" position.

    Definition Classes
    Positions
  89. abstract val NoPrefix: Type

    Permalink

    This constant is used as a special value denoting the empty prefix in a path dependent type.

    This constant is used as a special value denoting the empty prefix in a path dependent type. For instance x.type is represented as SingleType(NoPrefix, <x>), where <x> stands for the symbol for x.

    Definition Classes
    Types
  90. abstract val NoSymbol: Symbol

    Permalink

    A special "missing" symbol.

    A special "missing" symbol. Commonly used in the API to denote a default or empty value.

    Definition Classes
    Symbols
  91. abstract val NoType: Type

    Permalink

    This constant is used as a special value that indicates that no meaningful type exists.

    This constant is used as a special value that indicates that no meaningful type exists.

    Definition Classes
    Types
  92. abstract val NullaryMethodType: NullaryMethodTypeExtractor

    Permalink

    The constructor/extractor for NullaryMethodType instances.

    The constructor/extractor for NullaryMethodType instances.

    Definition Classes
    Types
  93. implicit abstract val NullaryMethodTypeTag: ClassTag[NullaryMethodType]

    Permalink
    Definition Classes
    ImplicitTags
  94. abstract val PackageDef: PackageDefExtractor

    Permalink

    The constructor/extractor for PackageDef instances.

    The constructor/extractor for PackageDef instances.

    Definition Classes
    Trees
  95. implicit abstract val PackageDefTag: ClassTag[PackageDef]

    Permalink
    Definition Classes
    ImplicitTags
  96. abstract val PolyType: PolyTypeExtractor

    Permalink

    The constructor/extractor for PolyType instances.

    The constructor/extractor for PolyType instances.

    Definition Classes
    Types
  97. implicit abstract val PolyTypeTag: ClassTag[PolyType]

    Permalink
    Definition Classes
    ImplicitTags
  98. implicit abstract val PositionTag: ClassTag[Position]

    Permalink
    Definition Classes
    ImplicitTags
  99. abstract val RefTree: RefTreeExtractor

    Permalink

    The constructor/extractor for RefTree instances.

    The constructor/extractor for RefTree instances.

    Definition Classes
    Trees
  100. implicit abstract val RefTreeTag: ClassTag[RefTree]

    Permalink
    Definition Classes
    ImplicitTags
  101. abstract val ReferenceToBoxed: ReferenceToBoxedExtractor

    Permalink

    The constructor/extractor for ReferenceToBoxed instances.

    The constructor/extractor for ReferenceToBoxed instances.

    Definition Classes
    Internals
  102. implicit abstract val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]

    Permalink

    Tag that preserves the identity of ReferenceToBoxed in the face of erasure.

    Tag that preserves the identity of ReferenceToBoxed in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.

    Definition Classes
    Internals
  103. abstract val RefinedType: RefinedTypeExtractor

    Permalink

    The constructor/extractor for RefinedType instances.

    The constructor/extractor for RefinedType instances.

    Definition Classes
    Types
  104. implicit abstract val RefinedTypeTag: ClassTag[RefinedType]

    Permalink
    Definition Classes
    ImplicitTags
  105. abstract val Return: ReturnExtractor

    Permalink

    The constructor/extractor for Return instances.

    The constructor/extractor for Return instances.

    Definition Classes
    Trees
  106. implicit abstract val ReturnTag: ClassTag[Return]

    Permalink
    Definition Classes
    ImplicitTags
  107. implicit abstract val RuntimeClassTag: ClassTag[RuntimeClass]

    Permalink
    Definition Classes
    ImplicitTags
  108. implicit abstract val ScopeTag: ClassTag[Scope]

    Permalink
    Definition Classes
    ImplicitTags
  109. abstract def Select(qualifier: Tree, sym: Symbol): Select

    Permalink

    A factory method for Select nodes.

    A factory method for Select nodes.

    Definition Classes
    Trees
  110. abstract val Select: SelectExtractor

    Permalink

    The constructor/extractor for Select instances.

    The constructor/extractor for Select instances.

    Definition Classes
    Trees
  111. abstract val SelectFromTypeTree: SelectFromTypeTreeExtractor

    Permalink

    The constructor/extractor for SelectFromTypeTree instances.

    The constructor/extractor for SelectFromTypeTree instances.

    Definition Classes
    Trees
  112. implicit abstract val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]

    Permalink
    Definition Classes
    ImplicitTags
  113. implicit abstract val SelectTag: ClassTag[Select]

    Permalink
    Definition Classes
    ImplicitTags
  114. abstract val SingleType: SingleTypeExtractor

    Permalink

    The constructor/extractor for SingleType instances.

    The constructor/extractor for SingleType instances.

    Definition Classes
    Types
  115. implicit abstract val SingleTypeTag: ClassTag[SingleType]

    Permalink
    Definition Classes
    ImplicitTags
  116. implicit abstract val SingletonTypeTag: ClassTag[SingletonType]

    Permalink
    Definition Classes
    ImplicitTags
  117. abstract val SingletonTypeTree: SingletonTypeTreeExtractor

    Permalink

    The constructor/extractor for SingletonTypeTree instances.

    The constructor/extractor for SingletonTypeTree instances.

    Definition Classes
    Trees
  118. implicit abstract val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]

    Permalink
    Definition Classes
    ImplicitTags
  119. abstract val Star: StarExtractor

    Permalink

    The constructor/extractor for Star instances.

    The constructor/extractor for Star instances.

    Definition Classes
    Trees
  120. implicit abstract val StarTag: ClassTag[Star]

    Permalink
    Definition Classes
    ImplicitTags
  121. abstract val Super: SuperExtractor

    Permalink

    The constructor/extractor for Super instances.

    The constructor/extractor for Super instances.

    Definition Classes
    Trees
  122. implicit abstract val SuperTag: ClassTag[Super]

    Permalink
    Definition Classes
    ImplicitTags
  123. abstract val SuperType: SuperTypeExtractor

    Permalink

    The constructor/extractor for SuperType instances.

    The constructor/extractor for SuperType instances.

    Definition Classes
    Types
  124. implicit abstract val SuperTypeTag: ClassTag[SuperType]

    Permalink
    Definition Classes
    ImplicitTags
  125. implicit abstract val SymTreeTag: ClassTag[SymTree]

    Permalink
    Definition Classes
    ImplicitTags
  126. implicit abstract val SymbolTag: ClassTag[Symbol]

    Permalink
    Definition Classes
    ImplicitTags
  127. abstract val Template: TemplateExtractor

    Permalink

    The constructor/extractor for Template instances.

    The constructor/extractor for Template instances.

    Definition Classes
    Trees
  128. implicit abstract val TemplateTag: ClassTag[Template]

    Permalink
    Definition Classes
    ImplicitTags
  129. abstract val TermName: TermNameExtractor

    Permalink

    The constructor/extractor for TermName instances.

    The constructor/extractor for TermName instances.

    Definition Classes
    Names
  130. implicit abstract val TermNameTag: ClassTag[TermName]

    Permalink
    Definition Classes
    ImplicitTags
  131. implicit abstract val TermSymbolTag: ClassTag[TermSymbol]

    Permalink
    Definition Classes
    ImplicitTags
  132. implicit abstract val TermTreeTag: ClassTag[TermTree]

    Permalink
    Definition Classes
    ImplicitTags
  133. abstract def This(sym: Symbol): Tree

    Permalink

    A factory method for This nodes.

    A factory method for This nodes.

    Definition Classes
    Trees
  134. abstract val This: ThisExtractor

    Permalink

    The constructor/extractor for This instances.

    The constructor/extractor for This instances.

    Definition Classes
    Trees
  135. implicit abstract val ThisTag: ClassTag[This]

    Permalink
    Definition Classes
    ImplicitTags
  136. abstract val ThisType: ThisTypeExtractor

    Permalink

    The constructor/extractor for ThisType instances.

    The constructor/extractor for ThisType instances.

    Definition Classes
    Types
  137. implicit abstract val ThisTypeTag: ClassTag[ThisType]

    Permalink
    Definition Classes
    ImplicitTags
  138. abstract val Throw: ThrowExtractor

    Permalink

    The constructor/extractor for Throw instances.

    The constructor/extractor for Throw instances.

    Definition Classes
    Trees
  139. implicit abstract val ThrowTag: ClassTag[Throw]

    Permalink
    Definition Classes
    ImplicitTags
  140. implicit abstract val TreeCopierTag: ClassTag[TreeCopier]

    Permalink
    Definition Classes
    ImplicitTags
  141. implicit abstract val TreeTag: ClassTag[Tree]

    Permalink
    Definition Classes
    ImplicitTags
  142. abstract val Try: TryExtractor

    Permalink

    The constructor/extractor for Try instances.

    The constructor/extractor for Try instances.

    Definition Classes
    Trees
  143. implicit abstract val TryTag: ClassTag[Try]

    Permalink
    Definition Classes
    ImplicitTags
  144. implicit abstract val TypTreeTag: ClassTag[TypTree]

    Permalink
    Definition Classes
    ImplicitTags
  145. abstract val TypeApply: TypeApplyExtractor

    Permalink

    The constructor/extractor for TypeApply instances.

    The constructor/extractor for TypeApply instances.

    Definition Classes
    Trees
  146. implicit abstract val TypeApplyTag: ClassTag[TypeApply]

    Permalink
    Definition Classes
    ImplicitTags
  147. abstract val TypeBounds: TypeBoundsExtractor

    Permalink

    The constructor/extractor for TypeBounds instances.

    The constructor/extractor for TypeBounds instances.

    Definition Classes
    Types
  148. implicit abstract val TypeBoundsTag: ClassTag[TypeBounds]

    Permalink
    Definition Classes
    ImplicitTags
  149. abstract val TypeBoundsTree: TypeBoundsTreeExtractor

    Permalink

    The constructor/extractor for TypeBoundsTree instances.

    The constructor/extractor for TypeBoundsTree instances.

    Definition Classes
    Trees
  150. implicit abstract val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]

    Permalink
    Definition Classes
    ImplicitTags
  151. abstract val TypeDef: TypeDefExtractor

    Permalink

    The constructor/extractor for TypeDef instances.

    The constructor/extractor for TypeDef instances.

    Definition Classes
    Trees
  152. implicit abstract val TypeDefTag: ClassTag[TypeDef]

    Permalink
    Definition Classes
    ImplicitTags
  153. abstract val TypeName: TypeNameExtractor

    Permalink

    The constructor/extractor for TypeName instances.

    The constructor/extractor for TypeName instances.

    Definition Classes
    Names
  154. implicit abstract val TypeNameTag: ClassTag[TypeName]

    Permalink
    Definition Classes
    ImplicitTags
  155. abstract val TypeRef: TypeRefExtractor

    Permalink

    The constructor/extractor for TypeRef instances.

    The constructor/extractor for TypeRef instances.

    Definition Classes
    Types
  156. implicit abstract val TypeRefTag: ClassTag[TypeRef]

    Permalink
    Definition Classes
    ImplicitTags
  157. implicit abstract val TypeSymbolTag: ClassTag[TypeSymbol]

    Permalink
    Definition Classes
    ImplicitTags
  158. implicit abstract val TypeTagg: ClassTag[Type]

    Permalink
    Definition Classes
    ImplicitTags
  159. abstract def TypeTree(tp: Type): TypeTree

    Permalink

    A factory method for TypeTree nodes.

    A factory method for TypeTree nodes.

    Definition Classes
    Trees
  160. abstract val TypeTree: TypeTreeExtractor

    Permalink

    The constructor/extractor for TypeTree instances.

    The constructor/extractor for TypeTree instances.

    Definition Classes
    Trees
  161. implicit abstract val TypeTreeTag: ClassTag[TypeTree]

    Permalink
    Definition Classes
    ImplicitTags
  162. abstract val Typed: TypedExtractor

    Permalink

    The constructor/extractor for Typed instances.

    The constructor/extractor for Typed instances.

    Definition Classes
    Trees
  163. implicit abstract val TypedTag: ClassTag[Typed]

    Permalink
    Definition Classes
    ImplicitTags
  164. abstract val UnApply: UnApplyExtractor

    Permalink

    The constructor/extractor for UnApply instances.

    The constructor/extractor for UnApply instances.

    Definition Classes
    Trees
  165. implicit abstract val UnApplyTag: ClassTag[UnApply]

    Permalink
    Definition Classes
    ImplicitTags
  166. abstract val ValDef: ValDefExtractor

    Permalink

    The constructor/extractor for ValDef instances.

    The constructor/extractor for ValDef instances.

    Definition Classes
    Trees
  167. implicit abstract val ValDefTag: ClassTag[ValDef]

    Permalink
    Definition Classes
    ImplicitTags
  168. implicit abstract val ValOrDefDefTag: ClassTag[ValOrDefDef]

    Permalink
    Definition Classes
    ImplicitTags
  169. abstract val WildcardType: Type

    Permalink

    An object representing an unknown type, used during type inference.

    An object representing an unknown type, used during type inference. If you see WildcardType outside of inference it is almost certainly a bug.

    Definition Classes
    Types
  170. implicit abstract def addFlagOps(left: FlagSet): FlagOps

    Permalink

    The API of FlagSet instances.

    The API of FlagSet instances.

    Definition Classes
    FlagSets
  171. abstract def annotationToTree(ann: Annotation): Tree

    Permalink
    Attributes
    protected[scala]
    Definition Classes
    Annotations
  172. abstract def appliedType(sym: Symbol, args: Type*): Type

    Permalink

    Definition Classes
    Types
    See also

    appliedType

  173. abstract def appliedType(sym: Symbol, args: List[Type]): Type

    Permalink

    Definition Classes
    Types
    See also

    appliedType

  174. abstract def appliedType(tycon: Type, args: Type*): Type

    Permalink

    Definition Classes
    Types
    See also

    appliedType

  175. abstract def appliedType(tycon: Type, args: List[Type]): Type

    Permalink

    A creator for type applications

    A creator for type applications

    Definition Classes
    Types
  176. abstract def atPos[T <: Tree](pos: Position)(tree: T): T

    Permalink

    Assigns a given position to all position-less nodes of a given AST.

    Assigns a given position to all position-less nodes of a given AST.

    Definition Classes
    Positions
  177. abstract val compat: Compat

    Permalink

    Provides enrichments to ensure source compatibility between Scala 2.10 and Scala 2.11.

    Provides enrichments to ensure source compatibility between Scala 2.10 and Scala 2.11. If in your reflective program for Scala 2.10 you've used something that's now become an internal API, a single compat._ import will fix things for you.

    Definition Classes
    Internals
  178. abstract val definitions: DefinitionsApi

    Permalink

    A value containing all standard definitions in DefinitionsApi

    A value containing all standard definitions in DefinitionsApi

    Definition Classes
    StandardDefinitions
  179. abstract def glb(ts: List[Type]): Type

    Permalink

    The greatest lower bound of a list of types, as determined by <:<.

    The greatest lower bound of a list of types, as determined by <:<.

    Definition Classes
    Types
  180. abstract val internal: Internal

    Permalink

    Definition Classes
    Internals
    See also

    InternalApi

  181. abstract def lub(xs: List[Type]): Type

    Permalink

    The least upper bound of a list of types, as determined by <:<.

    The least upper bound of a list of types, as determined by <:<.

    Definition Classes
    Types
  182. abstract def newCodePrinter(out: PrintWriter, tree: Tree, printRootPkg: Boolean): TreePrinter

    Permalink

    Hook to define what showCode(...) means.

    Hook to define what showCode(...) means.

    Attributes
    protected
    Definition Classes
    Printers
  183. abstract def newLazyTreeCopier: TreeCopier

    Permalink

    Creates a lazy tree copier.

    Creates a lazy tree copier.

    Definition Classes
    Trees
  184. abstract def newRawTreePrinter(out: PrintWriter): TreePrinter

    Permalink

    Hook to define what showRaw(...) means.

    Hook to define what showRaw(...) means.

    Attributes
    protected
    Definition Classes
    Printers
  185. abstract def newStrictTreeCopier: TreeCopier

    Permalink

    Creates a strict tree copier.

    Creates a strict tree copier.

    Definition Classes
    Trees
  186. abstract def newTreePrinter(out: PrintWriter): TreePrinter

    Permalink

    Hook to define what show(...) means.

    Hook to define what show(...) means.

    Attributes
    protected
    Definition Classes
    Printers
  187. abstract val noSelfType: ValDef

    Permalink

    An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the self parameter Template if there is no definition of a self value of self type.

    An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the self parameter Template if there is no definition of a self value of self type.

    Definition Classes
    Trees
  188. abstract val pendingSuperCall: Apply

    Permalink

    An empty superclass constructor call corresponding to: super.<init>() This is used as a placeholder in the primary constructor body in class templates to denote the insertion point of a call to superclass constructor after the typechecker figures out the superclass of a given template.

    An empty superclass constructor call corresponding to: super.<init>() This is used as a placeholder in the primary constructor body in class templates to denote the insertion point of a call to superclass constructor after the typechecker figures out the superclass of a given template.

    Definition Classes
    Trees
  189. abstract val rootMirror: Mirror

    Permalink

    The root mirror of this universe.

    The root mirror of this universe. This mirror contains standard Scala classes and types such as Any, AnyRef, AnyVal, Nothing, Null, and all classes loaded from scala-library, which are shared across all mirrors within the enclosing universe.

    Definition Classes
    Mirrors
  190. abstract def show(position: Position): String

    Permalink

    Renders a prettified representation of a position.

    Renders a prettified representation of a position.

    Definition Classes
    Printers
  191. abstract def show(flags: FlagSet): String

    Permalink

    Renders a prettified representation of a flag set.

    Renders a prettified representation of a flag set.

    Definition Classes
    Printers
  192. abstract def show(name: Name): String

    Permalink

    Renders a prettified representation of a name.

    Renders a prettified representation of a name.

    Definition Classes
    Printers
  193. abstract def showDecl(sym: Symbol): String

    Permalink

    Renders a string that represents a declaration of this symbol written in Scala.

    Renders a string that represents a declaration of this symbol written in Scala.

    Definition Classes
    Printers
  194. abstract def symbolOf[T](implicit arg0: WeakTypeTag[T]): TypeSymbol

    Permalink

    Type symbol of x as derived from a type tag.

    Type symbol of x as derived from a type tag.

    Definition Classes
    TypeTags
  195. abstract val termNames: TermNamesApi

    Permalink

    A value containing all standard term names.

    A value containing all standard term names.

    Definition Classes
    StandardNames
  196. abstract def treeToAnnotation(tree: Tree): Annotation

    Permalink
    Attributes
    protected[scala]
    Definition Classes
    Annotations
  197. abstract val typeNames: TypeNamesApi

    Permalink

    A value containing all standard type names.

    A value containing all standard type names.

    Definition Classes
    StandardNames
  198. abstract def wrappingPos(trees: List[Tree]): Position

    Permalink

    A position that wraps the non-empty set of trees.

    A position that wraps the non-empty set of trees. The point of the wrapping position is the point of the first trees' position. If all some the trees are non-synthetic, returns a range position enclosing the non-synthetic trees Otherwise returns a synthetic offset position to point.

    Definition Classes
    Positions
  199. abstract def wrappingPos(default: Position, trees: List[Tree]): Position

    Permalink

    A position that wraps a set of trees.

    A position that wraps a set of trees. The point of the wrapping position is the point of the default position. If some of the trees are ranges, returns a range position enclosing all ranges Otherwise returns default position.

    Definition Classes
    Positions
  200. abstract def Apply(sym: Symbol, args: Tree*): Tree

    Permalink

    A factory method for Apply nodes.

    A factory method for Apply nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"$sym(..$args)" instead

  201. abstract def ApplyConstructor(tpt: Tree, args: List[Tree]): Tree

    Permalink

    0-1 argument list new, based on a type tree.

    0-1 argument list new, based on a type tree.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"new $tpt(..$args)" instead

  202. abstract val ArrayArgument: ArrayArgumentExtractor

    Permalink

    The constructor/extractor for ArrayArgument instances.

    The constructor/extractor for ArrayArgument instances.

    Definition Classes
    Annotations
    Annotations
    @deprecated
    Deprecated

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

  203. abstract def Bind(sym: Symbol, body: Tree): Bind

    Permalink

    A factory method for Bind nodes.

    A factory method for Bind nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use the canonical Bind constructor to create a bind and then initialize its symbol manually

  204. abstract def Block(stats: Tree*): Block

    Permalink

    A factory method for Block nodes.

    A factory method for Block nodes. Flattens directly nested blocks.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"{..$stats}" instead. Flatten directly nested blocks manually if needed

  205. abstract def CaseDef(pat: Tree, body: Tree): CaseDef

    Permalink

    A factory method for CaseDef nodes.

    A factory method for CaseDef nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use cq"$pat => $body" instead

  206. abstract def Ident(name: String): Ident

    Permalink

    A factory method for Ident nodes.

    A factory method for Ident nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use Ident(TermName(name)) instead

  207. abstract val LiteralArgument: LiteralArgumentExtractor

    Permalink

    The constructor/extractor for LiteralArgument instances.

    The constructor/extractor for LiteralArgument instances.

    Definition Classes
    Annotations
    Annotations
    @deprecated
    Deprecated

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

  208. abstract val NestedArgument: NestedArgumentExtractor

    Permalink

    The constructor/extractor for NestedArgument instances.

    The constructor/extractor for NestedArgument instances.

    Definition Classes
    Annotations
    Annotations
    @deprecated
    Deprecated

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

  209. abstract def New(sym: Symbol, args: Tree*): Tree

    Permalink

    0-1 argument list new, based on a symbol.

    0-1 argument list new, based on a symbol.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"new ${sym.toType}(..$args)" instead

  210. abstract def New(tpe: Type, args: Tree*): Tree

    Permalink

    0-1 argument list new, based on a type.

    0-1 argument list new, based on a type.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"new $tpe(..$args)" instead

  211. abstract def New(tpt: Tree, argss: List[List[Tree]]): Tree

    Permalink

    Factory method for object creation new tpt(args_1)...(args_n) A New(t, as) is expanded to: (new t).<init>(as)

    Factory method for object creation new tpt(args_1)...(args_n) A New(t, as) is expanded to: (new t).<init>(as)

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"new $tpt(...$argss)" instead

  212. abstract def Select(qualifier: Tree, name: String): Select

    Permalink

    A factory method for Select nodes.

    A factory method for Select nodes. The string name argument is assumed to represent a TermName.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use Select(tree, TermName(name)) instead

  213. abstract def Super(sym: Symbol, mix: TypeName): Tree

    Permalink

    A factory method for Super nodes.

    A factory method for Super nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"$sym.super[$mix].x".qualifier instead

  214. abstract def Throw(tpe: Type, args: Tree*): Throw

    Permalink

    A factory method for Throw nodes.

    A factory method for Throw nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Use q"throw new $tpe(..$args)" instead

  215. abstract def Try(body: Tree, cases: (Tree, Tree)*): Try

    Permalink

    A factory method for Try nodes.

    A factory method for Try nodes.

    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) Convert cases into casedefs and use q"try $body catch { case ..$newcases }" instead

  216. abstract val build: ReificationSupportApi

    Permalink
    Definition Classes
    Internals
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use internal.reificationSupport instead

  217. abstract val emptyValDef: ValDef

    Permalink
    Definition Classes
    Trees
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use noSelfType instead

  218. abstract def newTermName(s: String): TermName

    Permalink

    Create a new term name.

    Create a new term name.

    Definition Classes
    Names
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use TermName instead

  219. abstract def newTypeName(s: String): TypeName

    Permalink

    Creates a new type name.

    Creates a new type name.

    Definition Classes
    Names
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use TypeName instead

  220. abstract val nme: TermNamesApi

    Permalink

    Definition Classes
    StandardNames
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use termNames instead

    See also

    termNames

  221. abstract val tpnme: TypeNamesApi

    Permalink

    Definition Classes
    StandardNames
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use typeNames instead

    See also

    typeNames

  222. abstract val treeBuild: TreeGen

    Permalink

    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use internal.gen instead

    See also

    internal.gen

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink

    Test two objects for inequality.

    Test two objects for inequality.

    returns

    true if !(this == that), false otherwise.

    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink

    Equivalent to x.hashCode except for boxed numeric types and null.

    Equivalent to x.hashCode except for boxed numeric types and null. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null returns a hashcode where null.hashCode throws a NullPointerException.

    returns

    a hash value consistent with ==

    Definition Classes
    AnyRef → Any
  3. def +(other: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to any2stringadd[Universe] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (Universe, B)

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  5. final def ==(arg0: Any): Boolean

    Permalink

    The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

    The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

    returns

    true if the receiver object is equivalent to the argument; false otherwise.

    Definition Classes
    AnyRef → Any
  6. object BooleanFlag extends Serializable

    Permalink

    Definition Classes
    Printers
  7. object Expr extends Serializable

    Permalink

    Constructor/Extractor for Expr.

    Constructor/Extractor for Expr.

    Can be useful, when having a tree and wanting to splice it in reify call, in which case the tree first needs to be wrapped in an expr.

    The main source of information about exprs is the scala.reflect.api.Exprs page.

    Definition Classes
    Exprs
  8. object Liftable extends Universe.StandardLiftableInstances

    Permalink

    Companion to Liftable type class that contains standard instances and provides a helper apply method to simplify creation of new ones.

    Companion to Liftable type class that contains standard instances and provides a helper apply method to simplify creation of new ones.

    Definition Classes
    Liftables
  9. def Modifiers(flags: FlagSet): Modifiers

    Permalink

    The factory for Modifiers instances.

    The factory for Modifiers instances.

    Definition Classes
    Trees
  10. def Modifiers(flags: FlagSet, privateWithin: Name): Modifiers

    Permalink

    The factory for Modifiers instances.

    The factory for Modifiers instances.

    Definition Classes
    Trees
  11. lazy val NoMods: Modifiers

    Permalink

    An empty Modifiers object: no flags, empty visibility annotation and no Scala annotations.

    An empty Modifiers object: no flags, empty visibility annotation and no Scala annotations.

    Definition Classes
    Trees
  12. object TypeTag extends Serializable

    Permalink

    Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

    Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

    Definition Classes
    TypeTags
  13. object Unliftable extends Universe.StandardUnliftableInstances

    Permalink

    Companion to Unliftable type class that contains standard instances and provides a helper apply method to simplify creation of new ones.

    Companion to Unliftable type class that contains standard instances and provides a helper apply method to simplify creation of new ones.

    Definition Classes
    Liftables
  14. object WeakTypeTag extends Serializable

    Permalink

    Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

    Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

    Definition Classes
    TypeTags
  15. final def asInstanceOf[T0]: T0

    Permalink

    Cast the receiver object to be of type T0.

    Cast the receiver object to be of type T0.

    Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

    returns

    the receiver object.

    Definition Classes
    Any
    Exceptions thrown

    ClassCastException if the receiver object is not an instance of the erasure of type T0.

  16. def clone(): AnyRef

    Permalink

    Create a copy of the receiver object.

    Create a copy of the receiver object.

    The default implementation of the clone method is platform dependent.

    returns

    a copy of the receiver object.

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
    Note

    not specified by SLS as a member of AnyRef

  17. def ensuring(cond: (Universe) ⇒ Boolean, msg: ⇒ Any): Universe

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  18. def ensuring(cond: (Universe) ⇒ Boolean): Universe

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  19. def ensuring(cond: Boolean, msg: ⇒ Any): Universe

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  20. def ensuring(cond: Boolean): Universe

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  21. final def eq(arg0: AnyRef): Boolean

    Permalink

    Tests whether the argument (that) is a reference to the receiver object (this).

    Tests whether the argument (that) is a reference to the receiver object (this).

    The eq method implements an equivalence relation on non-null instances of AnyRef, and has three additional properties:

    • It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
    • For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
    • null.eq(null) returns true.

    When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

    returns

    true if the argument is a reference to the receiver object; false otherwise.

    Definition Classes
    AnyRef
  22. def equals(arg0: Any): Boolean

    Permalink

    The equality method for reference types.

    The equality method for reference types. Default implementation delegates to eq.

    See also equals in scala.Any.

    returns

    true if the receiver object is equivalent to the argument; false otherwise.

    Definition Classes
    AnyRef → Any
  23. def finalize(): Unit

    Permalink

    Called by the garbage collector on the receiver object when there are no more references to the object.

    Called by the garbage collector on the receiver object when there are no more references to the object.

    The details of when and if the finalize method is invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
    Note

    not specified by SLS as a member of AnyRef

  24. def formatted(fmtstr: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to StringFormat[Universe] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  25. final def getClass(): Class[_]

    Permalink

    A representation that corresponds to the dynamic class of the receiver object.

    A representation that corresponds to the dynamic class of the receiver object.

    The nature of the representation is platform dependent.

    returns

    a representation that corresponds to the dynamic class of the receiver object.

    Definition Classes
    AnyRef → Any
    Note

    not specified by SLS as a member of AnyRef

  26. def hashCode(): Int

    Permalink

    The hashCode method for reference types.

    The hashCode method for reference types. See hashCode in scala.Any.

    returns

    the hash code value for this object.

    Definition Classes
    AnyRef → Any
  27. final def isInstanceOf[T0]: Boolean

    Permalink

    Test whether the dynamic type of the receiver object is T0.

    Test whether the dynamic type of the receiver object is T0.

    Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.

    returns

    true if the receiver object is an instance of erasure of type T0; false otherwise.

    Definition Classes
    Any
  28. def itransform(transformer: Transformer, tree: Tree): Tree

    Permalink

    Delegates the transformation strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.

    Delegates the transformation strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.

    Attributes
    protected
    Definition Classes
    Trees
  29. def itraverse(traverser: Traverser, tree: Tree): Unit

    Permalink

    Delegates the traversal strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.

    Delegates the traversal strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.

    Attributes
    protected
    Definition Classes
    Trees
  30. final def ne(arg0: AnyRef): Boolean

    Permalink

    Equivalent to !(this eq that).

    Equivalent to !(this eq that).

    returns

    true if the argument is not a reference to the receiver object; false otherwise.

    Definition Classes
    AnyRef
  31. final def notify(): Unit

    Permalink

    Wakes up a single thread that is waiting on the receiver object's monitor.

    Wakes up a single thread that is waiting on the receiver object's monitor.

    Definition Classes
    AnyRef
    Note

    not specified by SLS as a member of AnyRef

  32. final def notifyAll(): Unit

    Permalink

    Wakes up all threads that are waiting on the receiver object's monitor.

    Wakes up all threads that are waiting on the receiver object's monitor.

    Definition Classes
    AnyRef
    Note

    not specified by SLS as a member of AnyRef

  33. macro def reify[T](expr: T): Expr[T]

    Permalink

    Use reify to produce the abstract syntax tree representing a given Scala expression.

    Use reify to produce the abstract syntax tree representing a given Scala expression.

    For example:

    val five = reify{ 5 }         // Literal(Constant(5))
    reify{ 5.toString }           // Apply(Select(Literal(Constant(5)), TermName("toString")), List())
    reify{ five.splice.toString } // Apply(Select(five, TermName("toString")), List())

    The produced tree is path dependent on the Universe reify was called from.

    Use scala.reflect.api.Exprs#Expr.splice to embed an existing expression into a reify call. Use Expr to turn a Tree into an expression that can be spliced.

    Definition Classes
    Universe
  34. def render(what: Any, mkPrinter: (PrintWriter) ⇒ TreePrinter, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String

    Permalink

    Attributes
    protected
    Definition Classes
    Printers
  35. def show(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String

    Permalink

    Renders a representation of a reflection artifact as desugared Scala code.

    Renders a representation of a reflection artifact as desugared Scala code.

    Definition Classes
    Printers
  36. def showCode(tree: Tree, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printPositions: BooleanFlag = None, printRootPkg: Boolean = false): String

    Permalink

    Renders the code of the passed tree, so that: 1) it can be later compiled by scalac retaining the same meaning, 2) it looks pretty.

    Renders the code of the passed tree, so that: 1) it can be later compiled by scalac retaining the same meaning, 2) it looks pretty. #1 is available for unattributed trees and attributed trees #2 is more or less okay indentation-wise, but at the moment there's a lot of desugaring left in place, and that's what we plan to improve in the future. printTypes, printIds, printPositions options have the same meaning as for TreePrinter printRootPkg option is available only for attributed trees.

    Definition Classes
    Printers
  37. def showRaw(position: Position): String

    Permalink

    Renders internal structure of a position.

    Renders internal structure of a position.

    Definition Classes
    Printers
  38. def showRaw(flags: FlagSet): String

    Permalink

    Renders internal structure of a flag set.

    Renders internal structure of a flag set.

    Definition Classes
    Printers
  39. def showRaw(name: Name): String

    Permalink

    Renders internal structure of a name.

    Renders internal structure of a name.

    Definition Classes
    Printers
  40. def showRaw(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String

    Permalink

    Renders internal structure of a reflection artifact as the visualization of a Scala syntax tree.

    Renders internal structure of a reflection artifact as the visualization of a Scala syntax tree.

    Definition Classes
    Printers
  41. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  42. def toString(): String

    Permalink

    Creates a String representation of this object.

    Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.

    returns

    a String representation of the object.

    Definition Classes
    AnyRef → Any
  43. val treeCopy: TreeCopier

    Permalink

    The standard (lazy) tree copier.

    The standard (lazy) tree copier.

    Definition Classes
    Trees
  44. def treeToString(tree: Tree): String

    Permalink

    By default trees are printed with show

    By default trees are printed with show

    Attributes
    protected
    Definition Classes
    Printers
  45. def typeOf[T](implicit ttag: TypeTag[T]): Type

    Permalink

    Shortcut for implicitly[TypeTag[T]].tpe

    Shortcut for implicitly[TypeTag[T]].tpe

    Definition Classes
    TypeTags
  46. def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]

    Permalink

    Shortcut for implicitly[TypeTag[T]]

    Shortcut for implicitly[TypeTag[T]]

    Definition Classes
    TypeTags
  47. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  48. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  49. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  50. def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type

    Permalink

    Shortcut for implicitly[WeakTypeTag[T]].tpe

    Shortcut for implicitly[WeakTypeTag[T]].tpe

    Definition Classes
    TypeTags
  51. def weakTypeTag[T](implicit attag: WeakTypeTag[T]): WeakTypeTag[T]

    Permalink

    Shortcut for implicitly[WeakTypeTag[T]]

    Shortcut for implicitly[WeakTypeTag[T]]

    Definition Classes
    TypeTags
  52. def xtransform(transformer: Transformer, tree: Tree): Tree

    Permalink

    Provides an extension hook for the transformation strategy.

    Provides an extension hook for the transformation strategy. Future-proofs against new node types.

    Attributes
    protected
    Definition Classes
    Trees
  53. def xtraverse(traverser: Traverser, tree: Tree): Unit

    Permalink

    Provides an extension hook for the traversal strategy.

    Provides an extension hook for the traversal strategy. Future-proofs against new node types.

    Attributes
    protected
    Definition Classes
    Trees
  54. def [B](y: B): (Universe, B)

    Permalink
    Implicit information
    This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Deprecated Value Members

  1. def mkImporter(from0: api.Universe): Importer { val from: from0.type }

    Permalink
    Definition Classes
    Internals
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use internal.createImporter instead

  2. implicit def stringToTermName(s: String): TermName

    Permalink

    An implicit conversion from String to TermName.

    An implicit conversion from String to TermName. Enables an alternative notation "map": TermName as opposed to TermName("map").

    Definition Classes
    Names
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use explicit TermName(s) instead

  3. implicit def stringToTypeName(s: String): TypeName

    Permalink

    An implicit conversion from String to TypeName.

    An implicit conversion from String to TypeName. Enables an alternative notation "List": TypeName as opposed to TypeName("List").

    Definition Classes
    Names
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) Use explicit TypeName(s) instead

Inherited from api.Universe

Inherited from api.Internals

Inherited from Quasiquotes

Inherited from Liftables

Inherited from Printers

Inherited from Mirrors

Inherited from StandardLiftables

Inherited from StandardNames

Inherited from StandardDefinitions

Inherited from ImplicitTags

Inherited from TypeTags

Inherited from Exprs

Inherited from Positions

Inherited from Annotations

Inherited from Constants

Inherited from Trees

Inherited from api.Names

Inherited from Scopes

Inherited from FlagSets

Inherited from Types

Inherited from Symbols

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from Universe to any2stringadd[Universe]

Inherited by implicit conversion StringFormat from Universe to StringFormat[Universe]

Inherited by implicit conversion Ensuring from Universe to Ensuring[Universe]

Inherited by implicit conversion ArrowAssoc from Universe to ArrowAssoc[Universe]

Macro Specific Additions

Universe

API

Annotations

Constants

Definitions

Expressions

Extractors

Flags

Internal

Mirrors

Names

Positions

Printers

Scopes

Standard Names

Symbols

Trees

Types - Operations

TypeTags

Types

Tree Copying

Factories

Tree Traversal and Transformation

Ungrouped