Scala Reflection Library 2.13.16 - scala.reflect.runtime.JavaUniverse
Keywords: Scala Reflection Library 2.13.16 scala.reflect.runtime.JavaUniverse

Scala Reflection Library2.13.16 < Back


# Packages

-  package root
  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package reflect
  Definition Classes
    scala
-  package runtime

  Entry points into runtime reflection.

  Entry points into runtime reflection. See the overview page for details on how to use them.

  Definition Classes
    reflect
- JavaUniverse
- JavaUniverseForce
- ReflectionUtils

c

scala.reflect.runtime

# JavaUniverse

###

#### class JavaUniverse extends internal.SymbolTable with JavaUniverseForce with ReflectSetup with SymbolTable

An implementation of scala.reflect.api.Universe for runtime reflection using JVM classloaders.

Should not be instantiated directly, use scala.reflect.runtime.universe instead.

Self Type
  JavaUniverse
Source
  JavaUniverse.scala

Linear Supertypes
SymbolTable, runtime.ThreadLocalStorage, Gil, SynchronizedOps, SynchronizedTypes, SynchronizedSymbols, SymbolLoaders, JavaMirrors, TwoWayCaches, api.JavaUniverse, ReflectSetup, JavaUniverseForce, internal.SymbolTable, Reporting, Internals, FreshNames, Translations, PrivateWithin, ReificationSupport, StdCreators, StdAttachments, CapturedVariables, Importers, TypeDebugging, Positions, Printers, Trees, AnnotationCheckers, AnnotationInfos, StdNames, Transforms, InfoTransformers, BaseTypeSeqs, Constants, Definitions, Mirrors, Scopes, FlagSets, ExistentialsAndSkolems, Kinds, Variances, Types, internal.tpe.FindMembers, TypeConstraints, TypeMaps, GlbLubs, CommonOwners, TypeToStrings, TypeComparers, Symbols, Names, Collections, Universe, Universe, Internals, Quasiquotes, Liftables, Printers, Mirrors, StandardLiftables, StandardNames, StandardDefinitions, ImplicitTags, TypeTags, Exprs, Positions, Annotations, Constants, Trees, Names, Scopes, FlagSets, Types, Symbols, AnyRef, Any
Type Hierarchy
Content Hierarchy

Ordering

1. Grouped
2. Alphabetic
3. By Inheritance

Inherited

1. JavaUniverse
2. SymbolTable
3. ThreadLocalStorage
4. Gil
5. SynchronizedOps
6. SynchronizedTypes
7. SynchronizedSymbols
8. SymbolLoaders
9. JavaMirrors
10. TwoWayCaches
11. JavaUniverse
12. ReflectSetup
13. JavaUniverseForce
14. SymbolTable
15. Reporting
16. Internals
17. FreshNames
18. Translations
19. PrivateWithin
20. ReificationSupport
21. StdCreators
22. StdAttachments
23. CapturedVariables
24. Importers
25. TypeDebugging
26. Positions
27. Printers
28. Trees
29. AnnotationCheckers
30. AnnotationInfos
31. StdNames
32. Transforms
33. InfoTransformers
34. BaseTypeSeqs
35. Constants
36. Definitions
37. Mirrors
38. Scopes
39. FlagSets
40. ExistentialsAndSkolems
41. Kinds
42. Variances
43. Types
44. FindMembers
45. TypeConstraints
46. TypeMaps
47. GlbLubs
48. CommonOwners
49. TypeToStrings
50. TypeComparers
51. Symbols
52. Names
53. Collections
54. Universe
55. Universe
56. Internals
57. Quasiquotes
58. Liftables
59. Printers
60. Mirrors
61. StandardLiftables
62. StandardNames
63. StandardDefinitions
64. ImplicitTags
65. TypeTags
66. Exprs
67. Positions
68. Annotations
69. Constants
70. Trees
71. Names
72. Scopes
73. FlagSets
74. Types
75. Symbols
76. AnyRef
77. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Instance Constructors

1.  new JavaUniverse()

### Type Members

1.  trait AnnotationApi extends AnyRef

   The API of `Annotation` instances.

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

   Definition Classes
     Annotations
2.  abstract class AnnotationExtractor extends AnyRef

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

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

   Definition Classes
     Annotations
3.  abstract class ConstantApi extends AnyRef

   The API of Constant instances.

   The API of Constant instances.

   Definition Classes
     Constants
4.  abstract class ConstantExtractor extends AnyRef

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

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

   Definition Classes
     Constants
5.  trait Expr[+T] extends Equals with Serializable

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

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

   Definition Classes
     Exprs
6.  trait FlagOps extends Any

   The API of `FlagSet` instances.

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

   Definition Classes
     FlagSets
7.  trait FlagValues extends AnyRef

   All possible values that can constitute flag sets.

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

   Definition Classes
     FlagSets
8.  trait FreeTermSymbolApi extends Universe.TermSymbolApi

   The API of free term symbols.

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

   $SYMACCESSORS

   Definition Classes
     Internals
9.  trait FreeTypeSymbolApi extends Universe.TypeSymbolApi

   The API of free type symbols.

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

   $SYMACCESSORS

   Definition Classes
     Internals
10.  trait Importer extends AnyRef

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

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

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

    Reflection artifacts are firmly grounded in their `Universe`s, which is reflected by the fact that types of artifacts from different universes are not compatible. By using `Importer`s, 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 `Universe`s 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
11.  trait InternalApi extends AnyRef

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

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

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

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

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

    Definition Classes
      Internals
12.  trait ReferenceToBoxedApi extends Universe.TermTreeApi

    The API that all references support

    The API that all references support

    Definition Classes
      Internals
13.  abstract class ReferenceToBoxedExtractor extends AnyRef

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

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

    For example:

    var x = ... fun { x }

    Will emit:

    Ident(x)

    Which gets transformed to:

    Select(Ident(x), "elem")

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

    Definition Classes
      Internals
14.  trait ReificationSupportApi extends AnyRef

    This is an internal implementation class.

    This is an internal implementation class.

    Definition Classes
      Internals
15.  trait Liftable[T] extends AnyRef

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

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

    Definition Classes
      Liftables
    See also

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

16.  trait Unliftable[T] extends AnyRef

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

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

    Definition Classes
      Liftables
    See also

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

17.  trait ClassMirror extends Universe.TemplateMirror

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

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

    Definition Classes
      Mirrors
18.  trait FieldMirror extends AnyRef

    A mirror that reflects a field.

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

    Definition Classes
      Mirrors
19.  trait InstanceMirror extends AnyRef

    A mirror that reflects a runtime value.

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

    Definition Classes
      Mirrors
20.  trait MethodMirror extends AnyRef

    A mirror that reflects a method.

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

    Definition Classes
      Mirrors
21.  trait ModuleMirror extends Universe.TemplateMirror

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

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

    Definition Classes
      Mirrors
22.  trait ReflectiveMirror extends api.Mirror[Mirrors.this.type]

    A mirror that reflects instances and static classes.

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

    Definition Classes
      Mirrors
23.  trait RuntimeClassApi extends AnyRef

    Has no special methods.

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

    Definition Classes
      Mirrors
24.  trait RuntimeMirror extends api.Mirror[Mirrors.this.type] with Universe.ReflectiveMirror

    The API of a mirror for a reflective universe.

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

    Definition Classes
      Mirrors
25.  trait TemplateMirror extends AnyRef

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

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

    Definition Classes
      Mirrors
26.  abstract class NameApi extends AnyRef

    The API of Name instances.

    The API of Name instances.

    Definition Classes
      Names
27.  trait TermNameApi extends AnyRef

    Has no special methods.

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

    Definition Classes
      Names
28.  abstract class TermNameExtractor extends AnyRef

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

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

    Definition Classes
      Names
29.  trait TypeNameApi extends AnyRef

    Has no special methods.

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

    Definition Classes
      Names
30.  abstract class TypeNameExtractor extends AnyRef

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

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

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

    Definition Classes
      Printers
32.  implicit class Quasiquote extends AnyRef

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

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

    Definition Classes
      Quasiquotes
    See also

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

33.  trait MemberScopeApi extends Universe.ScopeApi

    The API that all member scopes support

    The API that all member scopes support

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

    The API that all scopes support

    The API that all scopes support

    Definition Classes
      Scopes
35.  trait DefinitionsApi extends Universe.StandardTypes

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

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

    Definition Classes
      StandardDefinitions
36.  trait StandardTypes extends AnyRef

    Defines standard types.

    Defines standard types.

    Definition Classes
      StandardDefinitions
37.  trait StandardLiftableInstances extends AnyRef
    Definition Classes
      StandardLiftables
38.  trait StandardUnliftableInstances extends AnyRef
    Definition Classes
      StandardLiftables
39.  trait NamesApi extends AnyRef

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

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

    Definition Classes
      StandardNames
40.  trait TermNamesApi extends Universe.NamesApi

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

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

    Definition Classes
      StandardNames
41.  trait TypeNamesApi extends Universe.NamesApi

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

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

    Definition Classes
      StandardNames
42.  trait ClassSymbolApi extends Universe.TypeSymbolApi

    The API of class symbols.

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

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

    Definition Classes
      Symbols
43.  trait MethodSymbolApi extends Universe.TermSymbolApi

    The API of method symbols.

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

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

    Definition Classes
      Symbols
44.  trait ModuleSymbolApi extends Universe.TermSymbolApi

    The API of module symbols.

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

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

    Definition Classes
      Symbols
45.  trait SymbolApi extends AnyRef

    The API of symbols.

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

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

    Definition Classes
      Symbols
46.  trait TermSymbolApi extends Universe.SymbolApi

    The API of term symbols.

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

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

    Definition Classes
      Symbols
47.  trait TypeSymbolApi extends Universe.SymbolApi

    The API of type symbols.

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

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

    Definition Classes
      Symbols
48.  trait AlternativeApi extends Universe.TermTreeApi

    The API that all alternatives support

    The API that all alternatives support

    Definition Classes
      Trees
49.  abstract class AlternativeExtractor extends AnyRef

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

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

    pat1 | ... | patn

    Definition Classes
      Trees
50.  trait AnnotatedApi extends Universe.TreeApi

    The API that all annotateds support

    The API that all annotateds support

    Definition Classes
      Trees
51.  abstract class AnnotatedExtractor extends AnyRef

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

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

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

    Definition Classes
      Trees
52.  trait AppliedTypeTreeApi extends Universe.TypTreeApi

    The API that all applied type trees support

    The API that all applied type trees support

    Definition Classes
      Trees
53.  abstract class AppliedTypeTreeExtractor extends AnyRef

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

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

    tpt[args]

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

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

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

    Definition Classes
      Trees
54.  trait ApplyApi extends Universe.GenericApplyApi

    The API that all applies support

    The API that all applies support

    Definition Classes
      Trees
55.  abstract class ApplyExtractor extends AnyRef

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

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

    fun(args)

    For instance:

    fun[targs](args)

    Is expressed as:

    Apply(TypeApply(fun, targs), args)

    Definition Classes
      Trees
56.  trait AssignApi extends Universe.TermTreeApi

    The API that all assigns support

    The API that all assigns support

    Definition Classes
      Trees
57.  abstract class AssignExtractor extends AnyRef

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

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

    lhs = rhs

    Definition Classes
      Trees
58.  trait BindApi extends Universe.DefTreeApi

    The API that all binds support

    The API that all binds support

    Definition Classes
      Trees
59.  abstract class BindExtractor extends AnyRef

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

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

    pat*

    Definition Classes
      Trees
60.  trait BlockApi extends Universe.TermTreeApi

    The API that all blocks support

    The API that all blocks support

    Definition Classes
      Trees
61.  abstract class BlockExtractor extends AnyRef

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

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

    { stats; expr }

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

    Definition Classes
      Trees
62.  trait CaseDefApi extends Universe.TreeApi

    The API that all case defs support

    The API that all case defs support

    Definition Classes
      Trees
63.  abstract class CaseDefExtractor extends AnyRef

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

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

    `case` pat `if` guard => body

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

    Definition Classes
      Trees
64.  trait ClassDefApi extends Universe.ImplDefApi

    The API that all class defs support

    The API that all class defs support

    Definition Classes
      Trees
65.  abstract class ClassDefExtractor extends AnyRef

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

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

    mods `class` name [tparams] impl

    Where impl stands for:

    `extends` parents { defs }

    Definition Classes
      Trees
66.  trait CompoundTypeTreeApi extends Universe.TypTreeApi

    The API that all compound type trees support

    The API that all compound type trees support

    Definition Classes
      Trees
67.  abstract class CompoundTypeTreeExtractor extends AnyRef

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

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

    parent1 with ... with parentN { refinement }

    Definition Classes
      Trees
68.  trait DefDefApi extends Universe.ValOrDefDefApi

    The API that all def defs support

    The API that all def defs support

    Definition Classes
      Trees
69.  abstract class DefDefExtractor extends AnyRef

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

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

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

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

    Definition Classes
      Trees
70.  trait DefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

    The API that all def trees support

    The API that all def trees support

    Definition Classes
      Trees
71.  trait ExistentialTypeTreeApi extends Universe.TypTreeApi

    The API that all existential type trees support

    The API that all existential type trees support

    Definition Classes
      Trees
72.  abstract class ExistentialTypeTreeExtractor extends AnyRef

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

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

    tpt forSome { whereClauses }

    Definition Classes
      Trees
73.  trait FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi

    The API that all functions support

    The API that all functions support

    Definition Classes
      Trees
74.  abstract class FunctionExtractor extends AnyRef

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

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

    vparams => body

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

    Definition Classes
      Trees
75.  trait GenericApplyApi extends Universe.TermTreeApi

    The API that all applies support

    The API that all applies support

    Definition Classes
      Trees
76.  trait IdentApi extends Universe.RefTreeApi

    The API that all idents support

    The API that all idents support

    Definition Classes
      Trees
77.  abstract class IdentExtractor extends AnyRef

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

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

    name

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

    Definition Classes
      Trees
78.  trait IfApi extends Universe.TermTreeApi

    The API that all ifs support

    The API that all ifs support

    Definition Classes
      Trees
79.  abstract class IfExtractor extends AnyRef

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

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

    `if` (cond) thenp `else` elsep

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

    Definition Classes
      Trees
80.  trait ImplDefApi extends Universe.MemberDefApi

    The API that all impl defs support

    The API that all impl defs support

    Definition Classes
      Trees
81.  trait ImportApi extends Universe.SymTreeApi

    The API that all imports support

    The API that all imports support

    Definition Classes
      Trees
82.  abstract class ImportExtractor extends AnyRef

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

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

    import expr.{selectors}

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

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

    Would be represented as:

    Import(qual, List(("w", WILDCARD), ("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
83.  trait ImportSelectorApi extends AnyRef

    The API that all import selectors support

    The API that all import selectors support

    Definition Classes
      Trees
84.  abstract class ImportSelectorExtractor extends AnyRef

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

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

    Definition Classes
      Trees
85.  trait LabelDefApi extends Universe.DefTreeApi with Universe.TermTreeApi

    The API that all label defs support

    The API that all label defs support

    Definition Classes
      Trees
86.  abstract class LabelDefExtractor extends AnyRef

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

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

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

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

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

    Definition Classes
      Trees
87.  trait LiteralApi extends Universe.TermTreeApi

    The API that all literals support

    The API that all literals support

    Definition Classes
      Trees
88.  abstract class LiteralExtractor extends AnyRef

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

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

    value

    Definition Classes
      Trees
89.  trait MatchApi extends Universe.TermTreeApi

    The API that all matches support

    The API that all matches support

    Definition Classes
      Trees
90.  abstract class MatchExtractor extends AnyRef

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

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

    selector `match` { cases }

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

    Definition Classes
      Trees
91.  trait MemberDefApi extends Universe.DefTreeApi

    The API that all member defs support

    The API that all member defs support

    Definition Classes
      Trees
92.  abstract class ModifiersApi extends AnyRef

    The API that all Modifiers support

    The API that all Modifiers support

    Definition Classes
      Trees
93.  abstract class ModifiersExtractor extends AnyRef

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

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

    Definition Classes
      Trees
94.  trait ModuleDefApi extends Universe.ImplDefApi

    The API that all module defs support

    The API that all module defs support

    Definition Classes
      Trees
95.  abstract class ModuleDefExtractor extends AnyRef

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

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

    mods `object` name impl

    Where impl stands for:

    `extends` parents { defs }

    Definition Classes
      Trees
96.  trait NameTreeApi extends Universe.TreeApi

    The API that all name trees support

    The API that all name trees support

    Definition Classes
      Trees
97.  trait NamedArgApi extends Universe.TermTreeApi

    The API that all assigns support

    The API that all assigns support

    Definition Classes
      Trees
98.  abstract class NamedArgExtractor extends AnyRef

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

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

        m.f(lhs = rhs)

        @annotation(lhs = rhs)

    Definition Classes
      Trees
99.  trait NewApi extends Universe.TermTreeApi

    The API that all news support

    The API that all news support

    Definition Classes
      Trees
100.  abstract class NewExtractor extends AnyRef

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

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

     `new` T

     This node always occurs in the following context:

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

     For example, an AST representation of:

     new Example[Int](2)(3)

     is the following code:

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

     Definition Classes
       Trees
101.  trait PackageDefApi extends Universe.MemberDefApi

     The API that all package defs support

     The API that all package defs support

     Definition Classes
       Trees
102.  abstract class PackageDefExtractor extends AnyRef

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

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

     `package` pid { stats }

     Definition Classes
       Trees
103.  trait RefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

     The API that all ref trees support

     The API that all ref trees support

     Definition Classes
       Trees
104.  abstract class RefTreeExtractor extends AnyRef

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

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

     Definition Classes
       Trees
105.  trait ReturnApi extends Universe.TermTreeApi

     The API that all returns support

     The API that all returns support

     Definition Classes
       Trees
106.  abstract class ReturnExtractor extends AnyRef

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

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

     `return` expr

     The symbol of a Return node is the enclosing method.

     Definition Classes
       Trees
107.  trait SelectApi extends Universe.RefTreeApi

     The API that all selects support

     The API that all selects support

     Definition Classes
       Trees
108.  abstract class SelectExtractor extends AnyRef

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

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

     qualifier.selector

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

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

     Definition Classes
       Trees
109.  trait SelectFromTypeTreeApi extends Universe.TypTreeApi with Universe.RefTreeApi

     The API that all selects from type trees support

     The API that all selects from type trees support

     Definition Classes
       Trees
110.  abstract class SelectFromTypeTreeExtractor extends AnyRef

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

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

     qualifier # selector

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

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

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

     Definition Classes
       Trees
111.  trait SingletonTypeTreeApi extends Universe.TypTreeApi

     The API that all singleton type trees support

     The API that all singleton type trees support

     Definition Classes
       Trees
112.  abstract class SingletonTypeTreeExtractor extends AnyRef

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

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

     ref.type

     Definition Classes
       Trees
113.  trait StarApi extends Universe.TermTreeApi

     The API that all stars support

     The API that all stars support

     Definition Classes
       Trees
114.  abstract class StarExtractor extends AnyRef

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

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

     pat*

     Definition Classes
       Trees
115.  trait SuperApi extends Universe.TermTreeApi

     The API that all supers support

     The API that all supers support

     Definition Classes
       Trees
116.  abstract class SuperExtractor extends AnyRef

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

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

     C.super[M]

     Which is represented as:

     Super(This(C), M)

     If `mix` is empty, it is tpnme.EMPTY.

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

     Definition Classes
       Trees
117.  trait SymTreeApi extends Universe.TreeApi

     The API that all sym trees support

     The API that all sym trees support

     Definition Classes
       Trees
118.  trait TemplateApi extends Universe.SymTreeApi

     The API that all templates support

     The API that all templates support

     Definition Classes
       Trees
119.  abstract class TemplateExtractor extends AnyRef

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

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

     `extends` parents { self => body }

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

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

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

     Definition Classes
       Trees
120.  trait TermTreeApi extends Universe.TreeApi

     The API that all term trees support

     The API that all term trees support

     Definition Classes
       Trees
121.  trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi

     The API that all thises support

     The API that all thises support

     Definition Classes
       Trees
122.  abstract class ThisExtractor extends AnyRef

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

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

     qual.this

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

     Definition Classes
       Trees
123.  trait ThrowApi extends Universe.TermTreeApi

     The API that all tries support

     The API that all tries support

     Definition Classes
       Trees
124.  abstract class ThrowExtractor extends AnyRef

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

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

     `throw` expr

     Definition Classes
       Trees
125.  abstract class Transformer extends AnyRef

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

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

     Definition Classes
       Trees
126.  class Traverser extends AnyRef

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

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

     Definition Classes
       Trees
127.  trait TreeApi extends Product

     The API that all trees support.

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

     Definition Classes
       Trees
128.  abstract class TreeCopierOps extends AnyRef

     The API of a tree copier.

     The API of a tree copier.

     Definition Classes
       Trees
129.  trait TryApi extends Universe.TermTreeApi

     The API that all tries support

     The API that all tries support

     Definition Classes
       Trees
130.  abstract class TryExtractor extends AnyRef

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

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

     `try` block `catch` { catches } `finally` finalizer

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

     Definition Classes
       Trees
131.  trait TypTreeApi extends Universe.TreeApi

     The API that all typ trees support

     The API that all typ trees support

     Definition Classes
       Trees
132.  trait TypeApplyApi extends Universe.GenericApplyApi

     The API that all type applies support

     The API that all type applies support

     Definition Classes
       Trees
133.  abstract class TypeApplyExtractor extends AnyRef

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

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

     fun[args]

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

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

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

     Definition Classes
       Trees
134.  trait TypeBoundsTreeApi extends Universe.TypTreeApi

     The API that all type bound trees support

     The API that all type bound trees support

     Definition Classes
       Trees
135.  abstract class TypeBoundsTreeExtractor extends AnyRef

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

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

     >: lo <: hi

     Definition Classes
       Trees
136.  trait TypeDefApi extends Universe.MemberDefApi

     The API that all type defs support

     The API that all type defs support

     Definition Classes
       Trees
137.  abstract class TypeDefExtractor extends AnyRef

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

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

     mods `type` name[tparams] = rhs

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

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

     Definition Classes
       Trees
138.  trait TypeTreeApi extends Universe.TypTreeApi

     The API that all type trees support

     The API that all type trees support

     Definition Classes
       Trees
139.  abstract class TypeTreeExtractor extends AnyRef

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

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

     Definition Classes
       Trees
140.  trait TypedApi extends Universe.TermTreeApi

     The API that all typeds support

     The API that all typeds support

     Definition Classes
       Trees
141.  abstract class TypedExtractor extends AnyRef

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

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

     expr: tpt

     Definition Classes
       Trees
142.  trait UnApplyApi extends Universe.TermTreeApi

     The API that all unapplies support

     The API that all unapplies support

     Definition Classes
       Trees
143.  abstract class UnApplyExtractor extends AnyRef

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

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

     Definition Classes
       Trees
144.  trait ValDefApi extends Universe.ValOrDefDefApi

     The API that all val defs support

     The API that all val defs support

     Definition Classes
       Trees
145.  abstract class ValDefExtractor extends AnyRef

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

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

     mods `val` name: tpt = rhs

     mods `var` name: tpt = rhs

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

     self: Bar => // self-types

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

     Definition Classes
       Trees
146.  trait ValOrDefDefApi extends Universe.MemberDefApi

     The API that all val defs and def defs support

     The API that all val defs and def defs support

     Definition Classes
       Trees
147.  trait TypeTag[T] extends Universe.WeakTypeTag[T] with Equals with Serializable

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

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

     Definition Classes
       TypeTags
     Annotations
       @implicitNotFound()
     See also

       scala.reflect.api.TypeTags

148.  trait WeakTypeTag[T] extends Equals with Serializable

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

     If an implicit value of type `WeakTypeTag[T]` is required, the compiler will create one, and the reflective representation of `T` can be accessed via the `tpe` field. Components of `T` can be references to type parameters or abstract types. Note that `WeakTypeTag` makes an effort to be as concrete as possible, i.e. if `TypeTag`s 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 `TypeTag`s, see the Reflection Guide: TypeTags

     Definition Classes
       TypeTags
     Annotations
       @implicitNotFound()
     See also

       scala.reflect.api.TypeTags

149.  trait AnnotatedTypeApi extends Universe.TypeApi

     The API that all annotated types support.

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

     Definition Classes
       Types
150.  abstract class AnnotatedTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
151.  trait BoundedWildcardTypeApi extends Universe.TypeApi

     The API that all this types support.

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

     Definition Classes
       Types
152.  abstract class BoundedWildcardTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
153.  trait ClassInfoTypeApi extends Universe.TypeApi

     The API that all class info types support.

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

     Definition Classes
       Types
154.  abstract class ClassInfoTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
155.  trait CompoundTypeApi extends AnyRef

     Has no special methods.

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

     Definition Classes
       Types
156.  trait ConstantTypeApi extends Universe.TypeApi

     The API that all constant types support.

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

     Definition Classes
       Types
157.  abstract class ConstantTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
158.  trait ExistentialTypeApi extends Universe.TypeApi

     The API that all existential types support.

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

     Definition Classes
       Types
159.  abstract class ExistentialTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
160.  trait MethodTypeApi extends Universe.TypeApi

     The API that all method types support.

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

     Definition Classes
       Types
161.  abstract class MethodTypeExtractor extends AnyRef

     An extractor class to create and pattern match with syntax `MethodType(params, restpe)` 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, restpe)` 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
162.  trait NullaryMethodTypeApi extends Universe.TypeApi

     The API that all nullary method types support.

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

     Definition Classes
       Types
163.  abstract class NullaryMethodTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
164.  trait PolyTypeApi extends Universe.TypeApi

     The API that all polymorphic types support.

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

     Definition Classes
       Types
165.  abstract class PolyTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
166.  trait RefinedTypeApi extends Universe.TypeApi

     The API that all refined types support.

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

     Definition Classes
       Types
167.  abstract class RefinedTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
168.  trait SingleTypeApi extends Universe.TypeApi

     The API that all single types support.

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

     Definition Classes
       Types
169.  abstract class SingleTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
170.  trait SingletonTypeApi extends AnyRef

     Has no special methods.

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

     Definition Classes
       Types
171.  trait SuperTypeApi extends Universe.TypeApi

     The API that all super types support.

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

     Definition Classes
       Types
172.  abstract class SuperTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
173.  trait ThisTypeApi extends Universe.TypeApi

     The API that all this types support.

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

     Definition Classes
       Types
174.  abstract class ThisTypeExtractor extends AnyRef

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

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

     Definition Classes
       Types
175.  abstract class TypeApi extends AnyRef

     The API of types.

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

     Definition Classes
       Types
176.  trait TypeBoundsApi extends Universe.TypeApi

     The API that all type bounds support.

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

     Definition Classes
       Types
177.  abstract class TypeBoundsExtractor extends AnyRef

     An extractor class to create and pattern match with syntax `TypeBound(lower, upper)` Here, `lower` is the lower bound of the `TypeBounds` pair, and `upper` is the upper bound.

     An extractor class to create and pattern match with syntax `TypeBound(lower, upper)` Here, `lower` is the lower bound of the `TypeBounds` pair, and `upper` is the upper bound.

     Definition Classes
       Types
178.  trait TypeRefApi extends Universe.TypeApi

     The API that all type refs support.

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

     Definition Classes
       Types
179.  abstract class TypeRefExtractor extends AnyRef

     An extractor class to create and pattern match with syntax `TypeRef(pre, sym, args)` Here, `pre` is the prefix of the type reference, `sym` is the symbol referred to by the type reference, and `args` is a possible empty list of type arguments.

     An extractor class to create and pattern match with syntax `TypeRef(pre, sym, args)` Here, `pre` is the prefix of the type reference, `sym` is the symbol referred to by the type reference, and `args` is a possible empty list of type arguments.

     Definition Classes
       Types
180.  trait MacroInternalApi extends InternalApi

     Definition Classes
       Universe
     See also

       InternalApi

181.  trait TreeGen extends AnyRef

     Definition Classes
       Universe
182.  trait AbstractTypeRef extends internal.SymbolTable.TypeRef with internal.SymbolTable.NonClassTypeRef
     Definition Classes
       Types
183.  class AbstractTypeSymbol extends internal.SymbolTable.TypeSymbol

     Let's say you have a type definition

     Let's say you have a type definition

         type T <: Number

     and tsym is the symbol corresponding to T. Then

         tsym is an instance of AbstractTypeSymbol
         tsym.info == TypeBounds(Nothing, Number)
         tsym.tpe  == TypeRef(NoPrefix, T, List())

     Definition Classes
       Symbols
184.  trait AliasTypeRef extends internal.SymbolTable.TypeRef with internal.SymbolTable.NonClassTypeRef
     Definition Classes
       Types
185.  class AliasTypeSymbol extends internal.SymbolTable.TypeSymbol
     Definition Classes
       Symbols
186.  case class Alternative extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AlternativeApi with Product with Serializable
     Definition Classes
       Trees
187.  trait Annotatable[Self] extends AnyRef
     Definition Classes
       AnnotationInfos
188.  case class Annotated extends internal.SymbolTable.Tree with internal.SymbolTable.AnnotatedApi with Product with Serializable
     Definition Classes
       Trees
189.  case class AnnotatedType extends internal.SymbolTable.Type with internal.SymbolTable.RewrappingTypeProxy with internal.SymbolTable.AnnotatedTypeApi with Product with Serializable

     A type carrying some annotations.

     A type carrying some annotations. Created by the typechecker when eliminating Annotated trees (see typedAnnotated).

     Definition Classes
       Types
190.  trait AnnotationChecker extends AnyRef

     An additional checker for annotations on types.

     An additional checker for annotations on types. Typically these are registered by compiler plugins with the addAnnotationChecker method.

     Definition Classes
       AnnotationCheckers
191.  trait AnnotationFilter extends internal.SymbolTable.TypeMap
     Definition Classes
       TypeMaps
192.  abstract class AnnotationInfo extends internal.SymbolTable.AnnotationApi

     Typed information about an annotation.

     Typed information about an annotation. It can be attached to either a symbol or an annotated type.

     Annotations are written to the classfile as Java annotations if `atp` conforms to `ClassfileAnnotation` (the classfile parser adds this interface to any Java annotation class).

     Annotations are pickled (written to scala symtab attribute in the classfile) if `atp` inherits form `StaticAnnotation`.

     `args` stores arguments to Scala annotations, represented as typed trees. Note that these trees are not transformed by any phases following the type-checker.

     `assocs` stores arguments to classfile annotations as name-value pairs.

     Definition Classes
       AnnotationInfos
193.  case class AntiPolyType extends internal.SymbolTable.Type with Product with Serializable

     A class remembering a type instantiation for some a set of overloaded polymorphic symbols.

     A class remembering a type instantiation for some a set of overloaded polymorphic symbols. Not used after phase `typer`.

     Definition Classes
       Types
194.  case class AppliedTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.AppliedTypeTreeApi with Product with Serializable
     Definition Classes
       Trees
195.  class AppliedTypeVar extends internal.SymbolTable.TypeVar

     Precondition: `params.length == typeArgs.length > 0` (enforced structurally).

     Precondition: `params.length == typeArgs.length > 0` (enforced structurally).

     Definition Classes
       Types
196.  case class Apply extends internal.SymbolTable.GenericApply with internal.SymbolTable.ApplyApi with Product with Serializable
     Definition Classes
       Trees
197.  case class ApplyDynamic extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with Product with Serializable
     Definition Classes
       Trees
198.  class ApplyImplicitView extends internal.SymbolTable.Apply
     Definition Classes
       Trees
199.  class ApplyToImplicitArgs extends internal.SymbolTable.Apply
     Definition Classes
       Trees
200.  class ArgsTypeRef extends internal.SymbolTable.TypeRef
     Definition Classes
       Types
201.  case class ArrayAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable

     Represents an array of classfile annotation arguments

     Represents an array of classfile annotation arguments

     Definition Classes
       AnnotationInfos
202.  case class ArrayValue extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with Product with Serializable

     An array of expressions.

     An array of expressions. This AST node needs to be translated in backend. It is used to pass arguments to vararg arguments. Introduced by compiler phase uncurry.

     This AST node does not have direct correspondence to Scala code, and is used to pass arguments to vararg arguments. For instance:

     printf("%s%d", foo, 42)

     Is translated to after compiler phase uncurry to:

     Apply( Ident("printf"), Literal("%s%d"), ArrayValue(<Any>, List(Ident("foo"), Literal(42))))

     Definition Classes
       Trees
203.  class AsSeenFromMap extends internal.SymbolTable.TypeMap with internal.SymbolTable.KeepOnlyTypeConstraints

     A map to compute the asSeenFrom method.

     A map to compute the asSeenFrom method.

     Definition Classes
       TypeMaps
204.  case class Assign extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AssignApi with Product with Serializable
     Definition Classes
       Trees
205.  trait Attachable extends AnyRef

     Common code between reflect-internal Symbol and Tree related to Attachments.

     Common code between reflect-internal Symbol and Tree related to Attachments.

     Definition Classes
       StdAttachments
206.  class BaseTypeSeq extends AnyRef

     Note: constructor is protected to force everyone to use the factory method newBaseTypeSeq instead.

     Note: constructor is protected to force everyone to use the factory method newBaseTypeSeq instead. This is necessary because when run from reflection every base type sequence needs to have a SynchronizedBaseTypeSeq as mixin.

     Definition Classes
       BaseTypeSeqs
207.  case class Bind extends internal.SymbolTable.DefTree with internal.SymbolTable.BindApi with Product with Serializable
     Definition Classes
       Trees
208.  case class Block extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.BlockApi with Product with Serializable
     Definition Classes
       Trees
209.  case class BoundedWildcardType extends internal.SymbolTable.ProtoType with internal.SymbolTable.BoundedWildcardTypeApi with Product with Serializable

     BoundedWildcardTypes, used only during type inference, are created in two places that I can find:

     BoundedWildcardTypes, used only during type inference, are created in two places that I can find:

     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
210.  trait CannotHaveAttrs extends internal.SymbolTable.Tree
     Definition Classes
       Trees
211.  case class CaseDef extends internal.SymbolTable.Tree with internal.SymbolTable.CaseDefApi with Product with Serializable
     Definition Classes
       Trees
212.  case class ChangeOwnerAttachment extends Product with Serializable
     Definition Classes
       StdAttachments
213.  class ChangeOwnerTraverser extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
214.  abstract class ChildSolidDescendantsCollector extends internal.SymbolTable.Traverser
     Definition Classes
       Positions
215.  case class ClassDef extends internal.SymbolTable.ImplDef with internal.SymbolTable.ClassDefApi with Product with Serializable
     Definition Classes
       Trees
216.  case class ClassInfoType extends internal.SymbolTable.CompoundType with internal.SymbolTable.ClassInfoTypeApi with Product with Serializable

     A class representing a class info

     A class representing a class info

     Definition Classes
       Types
217.  class ClassSymbol extends internal.SymbolTable.TypeSymbol with internal.SymbolTable.ClassSymbolApi

     A class for class symbols

     A class for class symbols

     Definition Classes
       Symbols
218.  class ClassUnwrapper extends internal.SymbolTable.TypeUnwrapper
     Definition Classes
       Types
219.  sealed abstract class ClassfileAnnotArg extends Product with internal.SymbolTable.JavaArgumentApi

     Arguments to constant annotations (Annotations defined in Java or extending ConstantAnnotation).

     Arguments to constant annotations (Annotations defined in Java or extending ConstantAnnotation). Arguments are either:

     - constants
     - arrays of constants
     - or nested classfile annotations (only for Java annotation)

     TODO: rename to `ConstantAnnotationArg`

     Definition Classes
       AnnotationInfos
     Annotations
       @nowarn()
220.  class CodePrinter extends internal.SymbolTable.InternalTreePrinter
     Definition Classes
       Printers
221.  class CollectTreeTraverser[T] extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
222.  class CollectTypeCollector[T] extends internal.SymbolTable.TypeCollector[List[T]]

     A map to implement the `collect` method.

     A map to implement the `collect` method.

     Definition Classes
       TypeMaps
223.  abstract class CommonNames extends internal.SymbolTable.NamesApi
     Definition Classes
       StdNames
224.  class CommonOwnerMap extends internal.SymbolTable.TypeCollector[internal.SymbolTable.Symbol]
     Attributes
       protected
     Definition Classes
       CommonOwners
225.  class CompleteAnnotationInfo extends internal.SymbolTable.AnnotationInfo
     Definition Classes
       AnnotationInfos
226.  abstract class CompoundType extends internal.SymbolTable.Type with internal.SymbolTable.CompoundTypeApi

     A common base class for intersection types and class types

     A common base class for intersection types and class types

     Definition Classes
       Types
227.  case class CompoundTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.CompoundTypeTreeApi with Product with Serializable
     Definition Classes
       Trees
228.  case class CompoundTypeTreeOriginalAttachment extends Product with Serializable

     Stores the trees that give rise to a refined type to be used in reification.

     Stores the trees that give rise to a refined type to be used in reification. Unfortunately typed `CompoundTypeTree` is lacking essential info, and the reifier cannot use `CompoundTypeTree.tpe`. Therefore we need this hack (see `Reshape.toPreTyperTypeTree` for a detailed explanation).

     Definition Classes
       StdAttachments
229.  case class Constant extends internal.SymbolTable.ConstantApi with Product with Serializable
     Definition Classes
       Constants
230.  abstract class ConstantType extends internal.SymbolTable.SingletonType with internal.SymbolTable.ConstantTypeApi

     A class representing a constant type.

     A class representing a constant type. A constant type is either the inferred type of a constant value or an explicit or inferred literal type. Both may be constant folded at the type level, however literal types are not folded at the term level and do not elide effects.

     Definition Classes
       Types
231.  class ContainsAnyKeyCollector extends internal.SymbolTable.ExistsTypeRefCollector
     Definition Classes
       TypeMaps
232.  class ContainsCollector extends internal.SymbolTable.ExistsTypeRefCollector

     A map to implement the `contains` method.

     A map to implement the `contains` method.

     Definition Classes
       TypeMaps
233.  case class CyclicReference extends internal.SymbolTable.TypeError with Product with Serializable

     An exception for cyclic references of symbol definitions

     An exception for cyclic references of symbol definitions

     Definition Classes
       Symbols
234.  case class DefDef extends internal.SymbolTable.ValOrDefDef with internal.SymbolTable.DefDefApi with Product with Serializable
     Definition Classes
       Trees
235.  sealed abstract class DefTree extends internal.SymbolTable.SymTree with internal.SymbolTable.NameTree with internal.SymbolTable.DefTreeApi
     Definition Classes
       Trees
236.  class DefaultPosAssigner extends internal.SymbolTable.InternalTraverser with internal.SymbolTable.PosAssigner
     Attributes
       protected
     Definition Classes
       Positions
237.  abstract class DefinitionsClass extends internal.SymbolTable.DefinitionsApi with internal.SymbolTable.ValueClassDefinitions
     Definition Classes
       Definitions
238.  class DottyOpaqueTypeAlias extends AnyRef
     Definition Classes
       StdAttachments
239.  class DottyParameterisedTrait extends AnyRef
     Definition Classes
       StdAttachments
240.  abstract case class ErasedValueType extends internal.SymbolTable.UniqueType with Product with Serializable

     A temporary type representing the erasure of a user-defined value type.

     A temporary type representing the erasure of a user-defined value type. Created during phase erasure, eliminated again in posterasure.

     scala/bug#6385 Erasure's creation of bridges considers method signatures `exitingErasure`, which contain `ErasedValueType`-s. In order to correctly consider the overriding and overridden signatures as equivalent in `run/t6385.scala`, it is critical that this type contains the erasure of the wrapped type, rather than the unerased type of the value class itself, as was originally done.

     Definition Classes
       Types
241.  class ErroneousAnnotation extends internal.SymbolTable.CompleteAnnotationInfo
     Definition Classes
       AnnotationInfos
242.  class ErrorScope extends internal.SymbolTable.Scope

     The error scope.

     The error scope.

     Definition Classes
       Scopes
243.  class ExistentialExtrapolation extends internal.SymbolTable.VariancedTypeMap

     Used by existentialAbstraction.

     Used by existentialAbstraction.

     Definition Classes
       TypeMaps
244.  case class ExistentialType extends internal.SymbolTable.Type with internal.SymbolTable.RewrappingTypeProxy with internal.SymbolTable.ExistentialTypeApi with Product with Serializable
     Definition Classes
       Types
245.  case class ExistentialTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.ExistentialTypeTreeApi with Product with Serializable
     Definition Classes
       Trees
246.  abstract class ExistsTypeRefCollector extends internal.SymbolTable.TypeCollector[Boolean]
     Definition Classes
       TypeMaps
247.  final class ExtraLazyAnnotationInfo extends internal.SymbolTable.LazyAnnotationInfo
     Definition Classes
       AnnotationInfos
248.  class FilterTreeTraverser extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
249.  class FilterTypeCollector extends internal.SymbolTable.TypeCollector[List[internal.SymbolTable.Type]]

     A map to implement the `filter` method.

     A map to implement the `filter` method.

     Definition Classes
       TypeMaps
250.  class FindTreeTraverser extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
251.  class FindTypeCollector extends internal.SymbolTable.TypeCollector[Option[internal.SymbolTable.Type]]

     A map to implement the `filter` method.

     A map to implement the `filter` method.

     Definition Classes
       TypeMaps
252.  case class FixedMirrorTreeCreator extends TreeCreator with Product with Serializable
     Definition Classes
       StdCreators
253.  case class FixedMirrorTypeCreator extends TypeCreator with Product with Serializable
     Definition Classes
       StdCreators
254.  trait FlagAgnosticCompleter extends internal.SymbolTable.LazyType

     A marker trait representing an as-yet unevaluated type which doesn't assign flags to the underlying symbol.

     A marker trait representing an as-yet unevaluated type which doesn't assign flags to the underlying symbol.

     Definition Classes
       Types
255.  trait FlagAssigningCompleter extends internal.SymbolTable.LazyType

     A marker trait representing an as-yet unevaluated type which assigns flags to the underlying symbol.

     A marker trait representing an as-yet unevaluated type which assigns flags to the underlying symbol.

     Definition Classes
       Types
256.  abstract case class FoldableConstantType extends internal.SymbolTable.ConstantType with Product with Serializable

     A class representing the inferred type of a constant value.

     A class representing the inferred type of a constant value. Constant types and their corresponding terms are constant-folded during type checking. To avoid constant folding, use the type returned by `deconst` instead.

     Definition Classes
       Types
257.  class ForEachTypeTraverser extends internal.SymbolTable.TypeTraverser
     Definition Classes
       TypeMaps
258.  class ForeachPartialTreeTraverser extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
259.  class ForeachTreeTraverser extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
260.  trait FreeSymbol extends internal.SymbolTable.Symbol
     Definition Classes
       Symbols
261.  class FreeTermSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.FreeSymbol with internal.SymbolTable.FreeTermSymbolApi
     Definition Classes
       Symbols
262.  class FreeTypeSymbol extends internal.SymbolTable.TypeSkolem with internal.SymbolTable.FreeSymbol with internal.SymbolTable.FreeTypeSymbolApi
     Definition Classes
       Symbols
263.  class FreshNameExtractor extends AnyRef
     Definition Classes
       FreshNames
264.  case class Function extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.FunctionApi with Product with Serializable
     Definition Classes
       Trees
265.  abstract class GenericApply extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.GenericApplyApi
     Definition Classes
       Trees
266.  class HKTypeVar extends internal.SymbolTable.TypeVar

     Precondition: !params.isEmpty.

     Precondition: !params.isEmpty. (args.nonEmpty enforced structurally.)

     Definition Classes
       Types
267.  case class Ident extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.IdentApi with Product with Serializable
     Definition Classes
       Trees
268.  case class If extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.IfApi with Product with Serializable
     Definition Classes
       Trees
269.  sealed abstract class ImplDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.ImplDefApi
     Definition Classes
       Trees
270.  case class Import extends internal.SymbolTable.SymTree with internal.SymbolTable.ImportApi with Product with Serializable
     Definition Classes
       Trees
271.  case class ImportSelector extends internal.SymbolTable.ImportSelectorApi with Product with Serializable
     Definition Classes
       Trees
272.  case class ImportType extends internal.SymbolTable.Type with Product with Serializable
     Definition Classes
       Types
273.  trait ImportableAttachment extends AnyRef

     Attachment that knows how to import itself into another universe.

     Attachment that knows how to import itself into another universe.

     Definition Classes
       StdAttachments
274.  abstract class InfoTransformer extends AnyRef
     Definition Classes
       InfoTransformers
275.  abstract class InlineAnnotatedAttachment extends AnyRef
     Definition Classes
       StdAttachments
276.  class InstantiateDependentMap extends internal.SymbolTable.TypeMap with internal.SymbolTable.KeepOnlyTypeConstraints

     Note: This map is needed even for non-dependent method types, despite what the name might imply.

     Note: This map is needed even for non-dependent method types, despite what the name might imply.

     Definition Classes
       TypeMaps
277.  type Internal = MacroInternalApi

     Definition Classes
       Internals → Internals
     See also

       InternalApi

278.  class InternalTransformer extends internal.SymbolTable.Transformer
     Definition Classes
       Trees
279.  class InternalTraverser extends internal.SymbolTable.Traverser
     Definition Classes
       Trees
280.  abstract class InternalTreeCopierOps extends internal.SymbolTable.TreeCopierOps
     Definition Classes
       Trees
281.  final type InternalTreePrinter = TreePrinter
     Definition Classes
       Printers
     Annotations
       @nowarn()
282.  class InvalidateTypeCaches extends internal.SymbolTable.TypeFolder
     Definition Classes
       Types
283.  trait JavaClassCompleter extends AnyRef
     Definition Classes
       JavaMirrors
284.  class JavaKeywords extends AnyRef
     Definition Classes
       StdNames
285.  class JavaRestrictedIdentifiers extends AnyRef
     Definition Classes
       StdNames
286.  trait KeepOnlyTypeConstraints extends internal.SymbolTable.TypeMap with internal.SymbolTable.AnnotationFilter
     Definition Classes
       TypeMaps
287.  abstract class Keywords extends internal.SymbolTable.CommonNames

     This should be the first trait in the linearization.

     This should be the first trait in the linearization.

     Definition Classes
       StdNames
288.  abstract class Kind extends AnyRef

     The data structure describing the kind of a given type.

     The data structure describing the kind of a given type.

     Proper types are represented using ProperTypeKind.

     Type constructors are represented using TypeConKind.

     Definition Classes
       Kinds
289.  case class KindErrors extends Product with Serializable
     Definition Classes
       Kinds
290.  case class LabelDef extends internal.SymbolTable.DefTree with internal.SymbolTable.TermTree with internal.SymbolTable.LabelDefApi with Product with Serializable
     Definition Classes
       Trees
291.  class LazyAnnotationInfo extends internal.SymbolTable.AnnotationInfo

     Symbol annotations parsed in `Namer` (typeCompleter of definitions) have to be lazy (#1782)

     Symbol annotations parsed in `Namer` (typeCompleter of definitions) have to be lazy (#1782)

     Definition Classes
       AnnotationInfos
292.  class LazyPackageType extends SymbolTable.LazyType with SymbolTable.FlagAgnosticCompleter

     The type completer for packages.

     The type completer for packages.

     Definition Classes
       SymbolLoaders
293.  abstract class LazyPolyType extends internal.SymbolTable.LazyType
     Definition Classes
       Types
294.  class LazyTreeCopier extends internal.SymbolTable.InternalTreeCopierOps
     Definition Classes
       Trees
295.  abstract class LazyType extends internal.SymbolTable.Type

     A class representing an as-yet unevaluated type.

     A class representing an as-yet unevaluated type.

     Definition Classes
       Types
296.  case class Literal extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.LiteralApi with Product with Serializable
     Definition Classes
       Trees
297.  case class LiteralAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable

     Represents a compile-time Constant (`Boolean`, `Byte`, `Short`, `Char`, `Int`, `Long`, `Float`, `Double`, `String`, `java.lang.Class` or an instance of a Java enumeration value).

     Represents a compile-time Constant (`Boolean`, `Byte`, `Short`, `Char`, `Int`, `Long`, `Float`, `Double`, `String`, `java.lang.Class` or an instance of a Java enumeration value).

     Definition Classes
       AnnotationInfos
298.  abstract case class LiteralType extends internal.SymbolTable.ConstantType with Product with Serializable

     A class representing an explicit or inferred literal type.

     A class representing an explicit or inferred literal type. Literal types may be be folded at at the type level during type checking, however they will not be folded at the term level and effects will not be elided.

     Definition Classes
       Types
299.  class LocalOwnersTraverser extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
300.  class Locator extends internal.SymbolTable.Traverser

     A locator for trees with given positions.

     A locator for trees with given positions. Given a position `pos`, locator.apply returns the smallest tree that encloses `pos`.

     Definition Classes
       Positions
301.  case class LookupAmbiguityWarning extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
302.  case class LookupAmbiguous extends internal.SymbolTable.NameLookup with Product with Serializable
     Definition Classes
       Scopes
303.  case class LookupInaccessible extends internal.SymbolTable.NameLookup with Product with Serializable
     Definition Classes
       Scopes
304.  case class LookupSucceeded extends internal.SymbolTable.NameLookup with Product with Serializable
     Definition Classes
       Scopes
305.  class MalformedType extends internal.SymbolTable.TypeError

     A throwable signalling a malformed type

     A throwable signalling a malformed type

     Definition Classes
       Types
306.  class MappedBaseTypeSeq extends internal.SymbolTable.BaseTypeSeq
     Definition Classes
       BaseTypeSeqs
307.  case class Match extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.MatchApi with Product with Serializable
     Definition Classes
       Trees
308.  sealed abstract class MemberDef extends internal.SymbolTable.DefTree with internal.SymbolTable.MemberDefApi
     Definition Classes
       Trees
309.  class MethodSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.MethodSymbolApi

     A class for method symbols

     A class for method symbols

     Definition Classes
       Symbols
310.  case class MethodType extends internal.SymbolTable.Type with internal.SymbolTable.MethodTypeApi with Product with Serializable

     A class representing a method type with parameters.

     A class representing a method type with parameters. Note that a parameterless method is represented by a NullaryMethodType:

     def m(): Int MethodType(Nil, Int) def m: Int NullaryMethodType(Int)

     Definition Classes
       Types
311.  type Mirror = JavaMirror

     In runtime reflection universes, mirrors are `JavaMirrors`.

     In runtime reflection universes, mirrors are `JavaMirrors`.

     Definition Classes
       JavaMirrors → JavaUniverse → Mirrors → Mirrors
312.  final type MirrorImpl = JavaMirror

     The API of a mirror for a reflective universe

     The API of a mirror for a reflective universe

     Definition Classes
       JavaMirrors
     Annotations
       @nowarn()
313.  class MissingAliasControl extends ControlThrowable
     Definition Classes
       Types
314.  class MissingTypeControl extends ControlThrowable
     Definition Classes
       Types
315.  case class Modifiers extends internal.SymbolTable.ModifiersApi with HasFlags with Product with Serializable

     Definition Classes
       Trees
316.  class ModuleClassSymbol extends internal.SymbolTable.ClassSymbol

     A class for module class symbols Note: Not all module classes are of this type; when unpickled, we get plain class symbols!

     A class for module class symbols Note: Not all module classes are of this type; when unpickled, we get plain class symbols!

     Definition Classes
       Symbols
317.  case class ModuleDef extends internal.SymbolTable.ImplDef with internal.SymbolTable.ModuleDefApi with Product with Serializable
     Definition Classes
       Trees
318.  class ModuleSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.ModuleSymbolApi

     A class for module symbols

     A class for module symbols

     Definition Classes
       Symbols
319.  class ModuleTypeRef extends internal.SymbolTable.NoArgsTypeRef
     Definition Classes
       Types
320.  sealed abstract class Name extends internal.Names.NameApi with NameHasIsEmpty with CharSequence

     The name class.

     The name class. TODO - resolve schizophrenia regarding whether to treat Names as Strings or Strings as Names. Give names the key functions the absence of which make people want Strings all the time.

     Definition Classes
       Names
321.  sealed trait NameHasIsEmpty extends AnyRef
     Definition Classes
       Names
322.  sealed trait NameLookup extends AnyRef

     An ADT to represent the results of symbol name lookups.

     An ADT to represent the results of symbol name lookups.

     Definition Classes
       Scopes
323.  case class NamePos extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
324.  trait NameTree extends internal.SymbolTable.Tree with internal.SymbolTable.NameTreeApi
     Definition Classes
       Trees
325.  case class NamedArg extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.NamedArgApi with Product with Serializable
     Definition Classes
       Trees
326.  case class NamedType extends internal.SymbolTable.Type with Product with Serializable

     A class representing types with a name.

     A class representing types with a name. When an application uses named arguments, the named argument types for calling isApplicable are represented as NamedType.

     Definition Classes
       Types
327.  case class NestedAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable

     Represents a nested classfile annotation

     Represents a nested classfile annotation

     Definition Classes
       AnnotationInfos
328.  case class New extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.NewApi with Product with Serializable
     Definition Classes
       Trees
329.  class NoArgsTypeRef extends internal.SymbolTable.TypeRef
     Definition Classes
       Types
330.  class NoCommonType extends ControlThrowable
     Definition Classes
       Types
331.  class NoSymbol extends internal.SymbolTable.Symbol

     An object representing a missing symbol

     An object representing a missing symbol

     Definition Classes
       Symbols
332.  trait NonClassTypeRef extends internal.SymbolTable.TypeRef
     Definition Classes
       Types
333.  case class NullaryMethodType extends internal.SymbolTable.Type with internal.SymbolTable.NullaryMethodTypeApi with Product with Serializable
     Definition Classes
       Types
334.  final case class OverloadedArgProto extends internal.SymbolTable.ProtoType with internal.SymbolTable.SimpleTypeProxy with Product with Serializable

     Lazily compute expected types for arguments to overloaded methods.

     Lazily compute expected types for arguments to overloaded methods. Primarily to improve parameter type inference for higher-order overloaded methods.

     Normally, overload resolution types the arguments to the alternatives without an expected type. However, typing function literals and eta-expansion are driven by the expected type:

     - function literals usually don't have parameter types, which are derived from the expected type;
     - eta-expansion right now only happens when a function/sam type is expected.

     Now that the collections are full of overloaded HO methods, we should try harder to type check them nicely.

     (This paragraph is conceptually true, but not a spec.) To avoid breaking existing code, we only provide an expected type (for each argument position) when:

     - there is at least one FunctionN type expected by one of the overloads: in this case, the expected type is a FunctionN[Ti, ?], where Ti are the argument types (they must all be =:=), and the expected result type is elided using a wildcard. This does not exclude any overloads that expect a SAM, because they conform to a function type through SAM conversion
     - OR: all overloads expect a SAM type of the same class, but with potentially varying result types (argument types must be =:=)
     - OR: all expected types collapse to the same type (by =:=, pushing down method type params to arguments types)

     We allow polymorphic cases, taking account any instantiation by the AntiPolyType prefix. Constructors of polymorphic classes are not supported (type param occurrences use fresh symbols, hard to relate to class's type params).

     In all other cases, the old behavior is maintained: Wildcard is expected.

     Definition Classes
       Types
335.  case class OverloadedType extends internal.SymbolTable.Type with Product with Serializable

     A class containing the alternatives and type prefix of an overloaded symbol.

     A class containing the alternatives and type prefix of an overloaded symbol. Not used after phase `typer`.

     Definition Classes
       Types
336.  class PackageClassInfoType extends internal.SymbolTable.ClassInfoType
     Definition Classes
       Types
337.  class PackageClassSymbol extends internal.SymbolTable.ModuleClassSymbol
     Definition Classes
       Symbols
338.  case class PackageDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.PackageDefApi with Product with Serializable
     Definition Classes
       Trees
339.  class PackageObjectClassSymbol extends internal.SymbolTable.ModuleClassSymbol
     Definition Classes
       Symbols
340.  class PackageScope extends SymbolTable.Scope with SymbolTable.SynchronizedScope
     Definition Classes
       SymbolLoaders
341.  class PackageTypeRef extends internal.SymbolTable.ModuleTypeRef
     Definition Classes
       Types
342.  case class PatShadowAttachment extends Product with Serializable

     A pattern binding that shadows a symbol in scope.

     A pattern binding that shadows a symbol in scope. Removed by refchecks.

     Definition Classes
       StdAttachments
343.  class PerRunReporting extends PerRunReportingBase
344.  abstract class PerRunReportingBase extends AnyRef
     Definition Classes
       Reporting
345.  type Period = Int

     A period is an ordinal number for a phase in a run.

     A period is an ordinal number for a phase in a run. Phases in later runs have higher periods than phases in earlier runs. Later phases have higher periods than earlier phases in the same run.

     Definition Classes
       SymbolTable
346.  case class PermittedSubclassSymbols extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
347.  case class PermittedSubclasses extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Java sealed classes may be qualified with a permits clause specifying allowed subclasses.

     Java sealed classes may be qualified with a permits clause specifying allowed subclasses.

     Definition Classes
       StdAttachments
348.  trait PlainAttachment extends internal.SymbolTable.ImportableAttachment

     Attachment that doesn't contain any reflection artifacts and can be imported as-is.

     Attachment that doesn't contain any reflection artifacts and can be imported as-is.

     Definition Classes
       StdAttachments
349.  case class PolyType extends internal.SymbolTable.Type with internal.SymbolTable.PolyTypeApi with Product with Serializable

     A type function or the type of a polymorphic value (and thus of kind *).

     A type function or the type of a polymorphic value (and thus of kind *).

     Before the introduction of NullaryMethodType, a polymorphic nullary method (e.g, def isInstanceOf[T]: Boolean) used to be typed as PolyType(tps, restpe), and a monomorphic one as PolyType(Nil, restpe) This is now: PolyType(tps, NullaryMethodType(restpe)) and NullaryMethodType(restpe) by symmetry to MethodTypes: PolyType(tps, MethodType(params, restpe)) and MethodType(params, restpe)

     Thus, a PolyType(tps, TypeRef(...)) unambiguously indicates a type function (which results from eta-expanding a type constructor alias). Similarly, PolyType(tps, ClassInfoType(...)) is a type constructor.

     A polytype is of kind * iff its resultType is a (nullary) method type.

     Definition Classes
       Types
350.  trait PosAssigner extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Positions
351.  type Position = internal.util.Position

     Defines a universe-specific notion of positions.

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

     Definition Classes
       Positions → Positions
352.  class ProperTypeKind extends internal.SymbolTable.Kind
     Definition Classes
       Kinds
353.  abstract class ProtoType extends internal.SymbolTable.Type
     Definition Classes
       Types
354.  class QualTypeSymAttachment extends AnyRef
     Definition Classes
       StdAttachments
355.  class RawTreePrinter extends internal.SymbolTable.TreePrinter
     Definition Classes
       Printers
356.  case class RecoverableCyclicReference extends internal.SymbolTable.TypeError with Product with Serializable

     An exception for cyclic references from which we can recover

     An exception for cyclic references from which we can recover

     Definition Classes
       Types
357.  trait RefTree extends internal.SymbolTable.SymTree with internal.SymbolTable.NameTree with internal.SymbolTable.RefTreeApi
     Definition Classes
       Trees
358.  case class ReferenceToBoxed extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.ReferenceToBoxedApi with Product with Serializable
     Definition Classes
       Trees
359.  case class RefinedType extends internal.SymbolTable.CompoundType with internal.SymbolTable.RefinedTypeApi with Product with Serializable

     A class representing intersection types with refinements of the form `<parents_0> with ... with <parents_n> { decls }` Cannot be created directly; one should always use `refinedType` for creation.

     A class representing intersection types with refinements of the form `<parents_0> with ... with <parents_n> { decls }` Cannot be created directly; one should always use `refinedType` for creation.

     Definition Classes
       Types
360.  final class RefinedType0 extends internal.SymbolTable.RefinedType
     Definition Classes
       Types
361.  class RefinementClassSymbol extends internal.SymbolTable.ClassSymbol
     Definition Classes
       Symbols
362.  class RefinementTypeRef extends internal.SymbolTable.NoArgsTypeRef
     Definition Classes
       Types
363.  trait ReflectStats extends BaseTypeSeqsStats with TypesStats with SymbolTableStats with TreesStats with SymbolsStats with ScopeStats
     Definition Classes
       SymbolTable
364.  class ReificationSupportImpl extends internal.SymbolTable.ReificationSupportApi
     Definition Classes
       ReificationSupport
365.  case class RepeatedType extends internal.SymbolTable.Type with Product with Serializable

     As with NamedType, used only when calling isApplicable.

     As with NamedType, used only when calling isApplicable. Records that the application has a wildcard star (aka _*) at the end of it.

     Definition Classes
       Types
366.  case class Return extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.ReturnApi with Product with Serializable
     Definition Classes
       Trees
367.  trait RewrappingTypeProxy extends internal.SymbolTable.Type with internal.SymbolTable.SimpleTypeProxy

     A proxy for a type (identified by field `underlying`) that forwards most operations to it.

     A proxy for a type (identified by field `underlying`) that forwards most operations to it. Every operation that is overridden for some kind of types is forwarded here. Some operations are rewrapped again.

     Definition Classes
       Types
368.  trait RootSymbol extends internal.SymbolTable.Symbol
     Definition Classes
       Mirrors
369.  abstract class Roots extends internal.SymbolTable.RootsBase
     Definition Classes
       Mirrors
370.  abstract class RootsBase extends api.Mirror[Mirrors.this.type]
     Definition Classes
       Mirrors
371.  type RunId = Int

     An ordinal number for compiler runs.

     An ordinal number for compiler runs. First run has number 1.

     Definition Classes
       SymbolTable
372.  trait RunReporting extends AnyRef
     Definition Classes
       Reporting
373.  type RuntimeClass = Class[_]

     In runtime reflection universes, runtime representation of a class is `java.lang.Class`.

     In runtime reflection universes, runtime representation of a class is `java.lang.Class`.

     Definition Classes
       JavaUniverse → Mirrors
374.  case class SAMFunction extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Attached to a Function node during type checking when the expected type is a SAM type (and not a built-in FunctionN).

     Attached to a Function node during type checking when the expected type is a SAM type (and not a built-in FunctionN).

     Ideally, we'd move to Dotty's Closure AST, which tracks the environment, the lifted method that has the implementation, and the target type. For backwards compatibility, an attachment is the best we can do right now.

     Definition Classes
       StdAttachments
375.  class Scope extends AbstractIterable[internal.SymbolTable.Symbol] with internal.SymbolTable.ScopeApi with internal.SymbolTable.MemberScopeApi

     Note: constructor is protected to force everyone to use the factory methods newScope or newNestedScope instead.

     Note: constructor is protected to force everyone to use the factory methods newScope or newNestedScope instead. This is necessary because when run from reflection every scope needs to have a SynchronizedScope as mixin.

     Definition Classes
       Scopes
376.  class ScopeEntry extends AnyRef
     Definition Classes
       Scopes
377.  case class Select extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.SelectApi with Product with Serializable
     Definition Classes
       Trees
378.  case class SelectFromTypeTree extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.TypTree with internal.SymbolTable.SelectFromTypeTreeApi with Product with Serializable
     Definition Classes
       Trees
379.  trait SimpleTypeProxy extends internal.SymbolTable.Type

     A proxy for a type (identified by field `underlying`) that forwards most operations to it (for exceptions, see WrappingProxy, which forwards even more operations).

     A proxy for a type (identified by field `underlying`) that forwards most operations to it (for exceptions, see WrappingProxy, which forwards even more operations). every operation that is overridden for some kind of types should be forwarded.

     Definition Classes
       Types
380.  abstract case class SingleType extends internal.SymbolTable.SingletonType with internal.SymbolTable.SingleTypeApi with Product with Serializable

     A class for singleton types of the form `<prefix>.<sym.name>.type`.

     A class for singleton types of the form `<prefix>.<sym.name>.type`. Cannot be created directly; one should always use `singleType` for creation.

     Definition Classes
       Types
381.  abstract class SingletonType extends internal.SymbolTable.SubType with internal.SymbolTable.SimpleTypeProxy with internal.SymbolTable.SingletonTypeApi

     A base class for types that represent a single value (single-types and this-types).

     A base class for types that represent a single value (single-types and this-types).

     Definition Classes
       Types
382.  case class SingletonTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.SingletonTypeTreeApi with Product with Serializable
     Definition Classes
       Trees
383.  abstract class StandardImporter extends internal.SymbolTable.Importer
     Definition Classes
       Importers
384.  case class Star extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.StarApi with Product with Serializable
     Definition Classes
       Trees
385.  class StrictTreeCopier extends internal.SymbolTable.InternalTreeCopierOps
     Definition Classes
       Trees
386.  class StubClassSymbol extends internal.SymbolTable.ClassSymbol with internal.SymbolTable.StubSymbol
     Definition Classes
       Symbols
387.  trait StubSymbol extends internal.SymbolTable.Symbol
     Definition Classes
       Symbols
388.  class StubTermSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.StubSymbol
     Definition Classes
       Symbols
389.  abstract class SubType extends internal.SymbolTable.UniqueType

     A base class for types that defer some operations to their immediate supertype.

     A base class for types that defer some operations to their immediate supertype.

     Definition Classes
       Types
390.  final case class SubTypePair extends Product with Serializable
     Definition Classes
       TypeComparers
391.  case class SubpatternsAttachment extends Product with Serializable

     Untyped list of subpatterns attached to selector dummy.

     Untyped list of subpatterns attached to selector dummy.

     Definition Classes
       StdAttachments
392.  abstract class SubstMap[T >: Null] extends internal.SymbolTable.TypeMap

     A base class to compute all substitutions.

     A base class to compute all substitutions.

     Definition Classes
       TypeMaps
393.  class SubstSymMap extends internal.SymbolTable.SubstMap[internal.SymbolTable.Symbol]

     A map to implement the `substSym` method.

     A map to implement the `substSym` method.

     Definition Classes
       TypeMaps
394.  class SubstThisMap extends internal.SymbolTable.TypeMap

     A map to implement the `substThis` method.

     A map to implement the `substThis` method.

     Definition Classes
       TypeMaps
395.  class SubstTypeMap extends internal.SymbolTable.SubstMap[internal.SymbolTable.Type]

     A map to implement the `subst` method.

     A map to implement the `subst` method.

     Definition Classes
       TypeMaps
396.  class SubstWildcardMap extends internal.SymbolTable.TypeMap
     Definition Classes
       TypeMaps
397.  case class Super extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.SuperApi with Product with Serializable
     Definition Classes
       Trees
398.  abstract case class SuperType extends internal.SymbolTable.SingletonType with internal.SymbolTable.SuperTypeApi with Product with Serializable
     Definition Classes
       Types
399.  abstract class SymLoader extends internal.SymbolTable.LazyType
     Definition Classes
       SymbolTable
400.  abstract class SymTree extends internal.SymbolTable.Tree with internal.SymbolTable.SymTreeApi
     Definition Classes
       Trees
401.  abstract class Symbol extends internal.SymbolTable.SymbolContextApiImpl with HasFlags with internal.SymbolTable.Annotatable[internal.SymbolTable.Symbol] with internal.SymbolTable.Attachable

     The class for all symbols

     The class for all symbols

     Definition Classes
       Symbols
402.  abstract class SymbolContextApiImpl extends internal.SymbolTable.SymbolApi
     Definition Classes
       Symbols
403.  sealed abstract class SymbolNames extends AnyRef
     Definition Classes
       StdNames
404.  case class SymbolOps extends Product with Serializable
     Definition Classes
       Symbols
405.  trait SymbolTableInternal extends internal.SymbolTable.MacroInternalApi
     Definition Classes
       Internals
406.  trait SynchronizedBaseTypeSeq extends SymbolTable.BaseTypeSeq
     Definition Classes
       SynchronizedOps
407.  trait SynchronizedClassSymbol extends SymbolTable.ClassSymbol with SymbolTable.SynchronizedTypeSymbol
     Definition Classes
       SynchronizedSymbols
408.  trait SynchronizedMethodSymbol extends SymbolTable.MethodSymbol with SymbolTable.SynchronizedTermSymbol
     Definition Classes
       SynchronizedSymbols
409.  trait SynchronizedModuleClassSymbol extends SymbolTable.ModuleClassSymbol with SymbolTable.SynchronizedClassSymbol
     Definition Classes
       SynchronizedSymbols
410.  trait SynchronizedModuleSymbol extends SymbolTable.ModuleSymbol with SymbolTable.SynchronizedTermSymbol
     Definition Classes
       SynchronizedSymbols
411.  trait SynchronizedScope extends SymbolTable.Scope
     Definition Classes
       SynchronizedOps
412.  trait SynchronizedSymbol extends SymbolTable.Symbol
     Definition Classes
       SynchronizedSymbols
413.  trait SynchronizedTermSymbol extends SymbolTable.Symbol with SymbolTable.SynchronizedSymbol
     Definition Classes
       SynchronizedSymbols
414.  trait SynchronizedTypeSymbol extends SymbolTable.TypeSymbol with SymbolTable.SynchronizedSymbol
     Definition Classes
       SynchronizedSymbols
415.  case class Template extends internal.SymbolTable.SymTree with internal.SymbolTable.TemplateApi with Product with Serializable
     Definition Classes
       Trees
416.  final class TermName extends Name with internal.Names.TermNameApi

     A name that contains no operator chars nor dollar signs.

     A name that contains no operator chars nor dollar signs. TODO - see if it's any faster to do something along these lines. Cute: now that exhaustivity kind of works, the mere presence of this trait causes TermName and TypeName to stop being exhaustive. Commented out.

     Definition Classes
       Names
417.  abstract class TermNames extends internal.SymbolTable.Keywords with internal.SymbolTable.TermNamesApi
     Definition Classes
       StdNames
418.  class TermSymbol extends internal.SymbolTable.Symbol with internal.SymbolTable.TermSymbolApi

     A class for term symbols

     A class for term symbols

     Definition Classes
       Symbols
419.  trait TermTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTreeApi
     Definition Classes
       Trees
420.  case class This extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.ThisApi with Product with Serializable
     Definition Classes
       Trees
421.  class ThisSubstituter extends internal.SymbolTable.InternalTransformer

     Substitute clazz.this with `to`.

     Substitute clazz.this with `to`. `to` must be an attributed tree.

     Definition Classes
       Trees
422.  abstract case class ThisType extends internal.SymbolTable.SingletonType with internal.SymbolTable.ThisTypeApi with Product with Serializable

     A class for this-types of the form <sym>.this.type

     A class for this-types of the form <sym>.this.type

     Definition Classes
       Types
423.  trait ThreadLocalStorage[T] extends AnyRef
     Definition Classes
       ThreadLocalStorage
424.  case class Throw extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.ThrowApi with Product with Serializable
     Definition Classes
       Trees
425.  class TopClassCompleter extends SymbolTable.SymLoader with SymbolTable.FlagAssigningCompleter

     The standard completer for top-level classes

     The standard completer for top-level classes

     Definition Classes
       SymbolLoaders
426.  abstract class Tree extends internal.SymbolTable.TreeContextApiImpl with internal.SymbolTable.Attachable with Product
     Definition Classes
       Trees
427.  abstract class TreeContextApiImpl extends internal.SymbolTable.TreeApi
     Definition Classes
       Trees
428.  type TreeCopier = InternalTreeCopierOps

     The type of standard (lazy) tree copiers.

     The type of standard (lazy) tree copiers.

     Definition Classes
       JavaUniverse → Trees → Trees
429.  class TreeReplacer extends internal.SymbolTable.InternalTransformer

     A transformer that replaces tree `from` with tree `to` in a given tree

     A transformer that replaces tree `from` with tree `to` in a given tree

     Definition Classes
       Trees
430.  trait TreeStackTraverser extends internal.SymbolTable.Traverser
     Definition Classes
       Trees
431.  class TreeSubstituter extends internal.SymbolTable.InternalTransformer
     Definition Classes
       Trees
432.  class TreeSymSubstTraverser extends internal.SymbolTable.TypeMapTreeSubstituter
     Definition Classes
       Trees
433.  class TreeSymSubstituter extends internal.SymbolTable.InternalTransformer

     Substitute symbols in `from` with symbols in `to`.

     Substitute symbols in `from` with symbols in `to`. Returns a new tree using the new symbols and whose Ident and Select nodes are name-consistent with the new symbols.

     Note: This is currently a destructive operation on the original Tree. Trees currently assigned a symbol in `from` will be assigned the new symbols without copying, and trees that define symbols with an `info` that refer a symbol in `from` will have a new type assigned.

     Definition Classes
       Trees
434.  class TreeTypeSubstituter extends internal.SymbolTable.TypeMapTreeSubstituter
     Definition Classes
       Trees
435.  case class Try extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.TryApi with Product with Serializable
     Definition Classes
       Trees
436.  class TwoWayCache[J, S] extends AnyRef
     Definition Classes
       TwoWayCaches
437.  trait TypTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTreeApi
     Definition Classes
       Trees
438.  abstract class Type extends internal.SymbolTable.TypeApiImpl with internal.SymbolTable.Annotatable[internal.SymbolTable.Type]

     The base class for all types

     The base class for all types

     Definition Classes
       Types
439.  abstract class TypeApiImpl extends internal.SymbolTable.TypeApi
     Definition Classes
       Types
440.  case class TypeApply extends internal.SymbolTable.GenericApply with internal.SymbolTable.TypeApplyApi with Product with Serializable
     Definition Classes
       Trees
441.  abstract case class TypeBounds extends internal.SymbolTable.SubType with internal.SymbolTable.TypeBoundsApi with Product with Serializable

     A class for the bounds of abstract types and type parameters

     A class for the bounds of abstract types and type parameters

     Definition Classes
       Types
442.  case class TypeBoundsTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.TypeBoundsTreeApi with Product with Serializable
     Definition Classes
       Trees
443.  abstract class TypeCollector[T] extends internal.SymbolTable.TypeFolder
     Definition Classes
       TypeMaps
444.  class TypeConKind extends internal.SymbolTable.Kind
     Definition Classes
       Kinds
445.  class TypeConstraint extends AnyRef

     A class expressing upper and lower bounds constraints of type variables, as well as their instantiations.

     A class expressing upper and lower bounds constraints of type variables, as well as their instantiations.

     Definition Classes
       TypeConstraints
446.  case class TypeDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.TypeDefApi with Product with Serializable
     Definition Classes
       Trees
447.  class TypeError extends Throwable

     A throwable signalling a type error

     A throwable signalling a type error

     Definition Classes
       Types
448.  abstract class TypeFolder extends (internal.SymbolTable.Type) => Unit
     Definition Classes
       TypeMaps
449.  abstract class TypeMap extends (internal.SymbolTable.Type) => internal.SymbolTable.Type

     A prototype for mapping a function over all possible types

     A prototype for mapping a function over all possible types

     Definition Classes
       TypeMaps
450.  class TypeMapTreeSubstituter extends internal.SymbolTable.InternalTraverser
     Definition Classes
       Trees
451.  final class TypeName extends Name with internal.Names.TypeNameApi
     Definition Classes
       Names
452.  abstract class TypeNames extends internal.SymbolTable.Keywords with internal.SymbolTable.TypeNamesApi
     Definition Classes
       StdNames
453.  case class TypeParamVarargsAttachment extends Product with Serializable

     An attachment carrying information between uncurry and erasure

     An attachment carrying information between uncurry and erasure

     Definition Classes
       StdAttachments
454.  abstract case class TypeRef extends internal.SymbolTable.UniqueType with internal.SymbolTable.TypeRefApi with Product with Serializable

     A class for named types of the form `<prefix>.<sym.name>[args]` Cannot be created directly; one should always use `typeRef` for creation.

     A class for named types of the form `<prefix>.<sym.name>[args]` Cannot be created directly; one should always use `typeRef` for creation. (\@M: Otherwise hashing breaks)

     \@M: a higher-kinded type is represented as a TypeRef with sym.typeParams.nonEmpty, but args.isEmpty

     Definition Classes
       Types
455.  class TypeSkolem extends internal.SymbolTable.TypeSymbol

     A class for type parameters viewed from inside their scopes

     A class for type parameters viewed from inside their scopes

     Definition Classes
       Symbols
456.  abstract class TypeSymbol extends internal.SymbolTable.Symbol with internal.SymbolTable.TypeSymbolApi

     A class of type symbols.

     A class of type symbols. Alias and abstract types are direct instances of this class. Classes are instances of a subclass.

     Definition Classes
       Symbols
457.  abstract class TypeTraverser extends internal.SymbolTable.TypeMap
     Definition Classes
       TypeMaps
458.  case class TypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.TypeTreeApi with Product with Serializable
     Definition Classes
       Trees
459.  class TypeUnwrapper extends (internal.SymbolTable.Type) => internal.SymbolTable.Type
     Definition Classes
       Types
460.  abstract case class TypeVar extends internal.SymbolTable.Type with Product with Serializable

     A class representing a type variable: not used after phase `typer`.

     A class representing a type variable: not used after phase `typer`.

     A higher-kinded TypeVar has params (Symbols) and typeArgs (Types). A TypeVar with nonEmpty typeArgs can only be instantiated by a higher-kinded type that can be applied to those args. A TypeVar is much like a TypeRef, except it has special logic for equality and subtyping.

     Precondition for this class, enforced structurally: args.isEmpty && params.isEmpty.

     Definition Classes
       Types
461.  case class Typed extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.TypedApi with Product with Serializable
     Definition Classes
       Trees
462.  class TypedLocator extends internal.SymbolTable.Locator
     Definition Classes
       Positions
463.  case class UnApply extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.UnApplyApi with Product with Serializable
     Definition Classes
       Trees
464.  class UndoLog extends Clearable
     Definition Classes
       TypeConstraints
465.  final class UniqueConstantType extends internal.SymbolTable.FoldableConstantType
     Definition Classes
       Types
466.  final class UniqueErasedValueType extends internal.SymbolTable.ErasedValueType
     Definition Classes
       Types
467.  final class UniqueLiteralType extends internal.SymbolTable.LiteralType
     Definition Classes
       Types
468.  final class UniqueSingleType extends internal.SymbolTable.SingleType
     Definition Classes
       Types
469.  final class UniqueSuperType extends internal.SymbolTable.SuperType
     Definition Classes
       Types
470.  final class UniqueThisType extends internal.SymbolTable.ThisType
     Definition Classes
       Types
471.  abstract class UniqueType extends internal.SymbolTable.Type with Product

     A type that can be passed to unique(..) and be stored in the uniques map.

     A type that can be passed to unique(..) and be stored in the uniques map.

     Definition Classes
       Types
472.  final class UniqueTypeBounds extends internal.SymbolTable.TypeBounds
     Definition Classes
       Types
473.  trait UntouchableTypeVar extends internal.SymbolTable.TypeVar
     Definition Classes
       Types
474.  case class ValDef extends internal.SymbolTable.ValOrDefDef with internal.SymbolTable.ValDefApi with Product with Serializable
     Definition Classes
       Trees
475.  sealed abstract class ValOrDefDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.ValOrDefDefApi
     Definition Classes
       Trees
476.  class ValidateException extends Exception
     Definition Classes
       Positions
477.  trait ValueClassDefinitions extends AnyRef
     Definition Classes
       Definitions
478.  class VarianceValidator extends internal.SymbolTable.InternalTraverser

     Used in Refchecks.

     Used in Refchecks. TODO - eliminate duplication with varianceInType

     Definition Classes
       Variances
479.  abstract class VariancedTypeMap extends internal.SymbolTable.TypeMap
     Definition Classes
       TypeMaps

### Deprecated Type Members

1.  trait JavaArgumentApi extends AnyRef

   Has no special methods.

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

   Definition Classes
     Annotations
   Annotations
     @deprecated
   Deprecated

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

2.  trait CompatApi extends AnyRef

   Definition Classes
     Internals
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

   See also

     compat

3.  class CompatToken extends AnyRef

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

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

   Definition Classes
     Internals
   Annotations
     @implicitNotFound() @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

4.  abstract type CompilationUnit <: CompilationUnitContextApi

   The type of compilation units.

   The type of compilation units.

   Definition Classes
     Universe
   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

5.  trait CompilationUnitContextApi extends AnyRef

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

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

   Definition Classes
     Universe
   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

6.  trait MacroCompatApi extends CompatApi

   Definition Classes
     Universe
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

   See also

     compat

7.  abstract type Run <: RunContextApi

   The type of compilation runs.

   The type of compilation runs.

   Definition Classes
     Universe
   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

8.  trait RunContextApi extends AnyRef

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

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

   Definition Classes
     Universe
   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

9.  type Compat = MacroCompatApi

   Definition Classes
     Internals → Internals
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

   See also

     compat

10.  class JavaMirror extends SymbolTable.Roots with SymbolTable.JavaMirror

    The API of a mirror for a reflective universe.

    The API of a mirror for a reflective universe.

    Definition Classes
      JavaMirrors
    Annotations
      @nowarn() @deprecated
    Deprecated

      (Since version 2.13.4) use MirrorImpl instead

11.  type ModifiersCreator = ModifiersExtractor
    Definition Classes
      Trees
    Annotations
      @deprecated
    Deprecated

      (Since version 2.11.0) use ModifiersExtractor instead

12.  class TreePrinter extends internal.SymbolTable.TreePrinter
    Definition Classes
      Printers
    Annotations
      @nowarn() @deprecated
    Deprecated

      (Since version 2.13.4) use InternalTreePrinter instead

### Value Members

1.  object Expr extends java.io.Serializable

   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
2.  object Liftable extends Universe.StandardLiftableInstances

   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
3.  object Unliftable extends Universe.StandardUnliftableInstances

   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
4.  object BooleanFlag extends java.io.Serializable

   Definition Classes
     Printers
5.  object TypeTag extends java.io.Serializable

   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
6.  object WeakTypeTag extends java.io.Serializable

   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
7.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
8.  final def ##: Int
   Definition Classes
     AnyRef → Any
9.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from JavaUniverse toany2stringadd[JavaUniverse] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
10.  def ->[B](y: B): (JavaUniverse, B)
    Implicit
      This member is added by an implicit conversion from JavaUniverse toArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
      ArrowAssoc
    Annotations
      @inline()
11.  final def ==(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
12.  val AllOps: SymbolOps
    Definition Classes
      Symbols
13.  implicit val AlternativeTag: ClassTag[Alternative]
    Definition Classes
      Trees
14.  implicit val AnnotatedTag: ClassTag[Annotated]
    Definition Classes
      Trees
15.  implicit val AnnotatedTypeTag: ClassTag[AnnotatedType]
    Definition Classes
      Types
16.  implicit val AnnotationTag: ClassTag[AnnotationInfo]
    Definition Classes
      AnnotationInfos
17.  implicit val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]
    Definition Classes
      Trees
18.  def Apply(sym: Symbol, args: Tree*): Tree

    A factory method for `Apply` nodes.

    A factory method for `Apply` nodes.

    Definition Classes
      Trees → Trees
19.  def ApplyConstructor(tpt: Tree, args: List[Tree]): Apply

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

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

    Definition Classes
      Trees → Trees
20.  implicit val ApplyTag: ClassTag[Apply]
    Definition Classes
      Trees
21.  implicit val AssignTag: ClassTag[Assign]
    Definition Classes
      Trees
22.  def Bind(sym: Symbol, body: Tree): Bind

    A factory method for `Bind` nodes.

    A factory method for `Bind` nodes.

    Definition Classes
      Trees → Trees
23.  implicit val BindTag: ClassTag[Bind]
    Definition Classes
      Trees
24.  def Block(stats: Tree*): Block

    Block factory that flattens directly nested blocks.

    Block factory that flattens directly nested blocks.

    Definition Classes
      Trees → Trees
25.  implicit val BlockTag: ClassTag[Block]
    Definition Classes
      Trees
26.  final val BooleanTag: Int(2)
    Definition Classes
      Constants
27.  implicit val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]
    Definition Classes
      Types
28.  final val ByteTag: Int(3)
    Definition Classes
      Constants
29.  def CaseDef(pat: Tree, body: Tree): CaseDef

    casedef shorthand

    casedef shorthand

    Definition Classes
      Trees → Trees
30.  implicit val CaseDefTag: ClassTag[CaseDef]
    Definition Classes
      Trees
31.  final val CharTag: Int(5)
    Definition Classes
      Constants
32.  implicit val ClassDefTag: ClassTag[ClassDef]
    Definition Classes
      Trees
33.  implicit val ClassInfoTypeTag: ClassTag[ClassInfoType]
    Definition Classes
      Types
34.  implicit val ClassSymbolTag: ClassTag[ClassSymbol]
    Definition Classes
      Symbols
35.  final val ClazzTag: Int(12)
    Definition Classes
      Constants
36.  implicit val CompoundTypeTag: ClassTag[CompoundType]
    Definition Classes
      Types
37.  implicit val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]
    Definition Classes
      Trees
38.  implicit val ConstantTag: ClassTag[Constant]
    Definition Classes
      Constants
39.  implicit val ConstantTypeTag: ClassTag[ConstantType]
    Definition Classes
      Types
40.  val CyclicInheritance: java.lang.Throwable
    Definition Classes
      BaseTypeSeqs
41.  implicit val DefDefTag: ClassTag[DefDef]
    Definition Classes
      Trees
42.  implicit val DefTreeTag: ClassTag[DefTree]
    Definition Classes
      Trees
43.  final val DoubleTag: Int(9)
    Definition Classes
      Constants
44.  lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter
    Definition Classes
      Trees
45.  final val EnumTag: Int(13)
    Definition Classes
      Constants
46.  implicit val ExistentialTypeTag: ClassTag[ExistentialType]
    Definition Classes
      Types
47.  implicit val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]
    Definition Classes
      Trees
48.  def FlagOps(mask: Long): SymbolOps
    Definition Classes
      Symbols
49.  implicit val FlagSetTag: ClassTag[FlagSet]
    Definition Classes
      FlagSets
50.  final val FloatTag: Int(8)
    Definition Classes
      Constants
51.  implicit val FreeTermSymbolTag: ClassTag[FreeTermSymbol]
    Definition Classes
      Symbols
52.  implicit val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
    Definition Classes
      Symbols
53.  implicit val FunctionTag: ClassTag[Function]
    Definition Classes
      Trees
54.  implicit val GenericApplyTag: ClassTag[GenericApply]
    Definition Classes
      Trees
55.  val GlbFailure: java.lang.Throwable
    Definition Classes
      GlbLubs
56.  def Ident(sym: Symbol): Ident

    A factory method for `Ident` nodes.

    A factory method for `Ident` nodes.

    Definition Classes
      Trees → Trees
57.  def Ident(name: String): Ident

    A factory method for `Ident` nodes.

    A factory method for `Ident` nodes.

    Definition Classes
      Trees → Trees
58.  implicit val IdentTag: ClassTag[Ident]
    Definition Classes
      Trees
59.  implicit val IfTag: ClassTag[If]
    Definition Classes
      Trees
60.  implicit val ImplDefTag: ClassTag[ImplDef]
    Definition Classes
      Trees
61.  implicit val ImportSelectorTag: ClassTag[ImportSelector]
    Definition Classes
      Trees
62.  implicit val ImportTag: ClassTag[Import]
    Definition Classes
      Trees
63.  final val IntTag: Int(6)
    Definition Classes
      Constants
64.  implicit val JavaArgumentTag: ClassTag[ClassfileAnnotArg]
    Definition Classes
      AnnotationInfos
65.  implicit val LabelDefTag: ClassTag[LabelDef]
    Definition Classes
      Trees
66.  implicit val LiteralTag: ClassTag[Literal]
    Definition Classes
      Trees
67.  final val LongTag: Int(7)
    Definition Classes
      Constants
68.  implicit val MatchTag: ClassTag[Match]
    Definition Classes
      Trees
69.  implicit val MemberDefTag: ClassTag[MemberDef]
    Definition Classes
      Trees
70.  implicit val MemberScopeTag: ClassTag[MemberScope]
    Definition Classes
      Scopes
71.  implicit val MethodSymbolTag: ClassTag[MethodSymbol]
    Definition Classes
      Symbols
72.  implicit val MethodTypeTag: ClassTag[MethodType]
    Definition Classes
      Types
73.  implicit val MirrorTag: ClassTag[Mirror]
    Definition Classes
      JavaMirrors → ImplicitTags
74.  def Modifiers(flags: FlagSet): Modifiers

    The factory for `Modifiers` instances.

    The factory for `Modifiers` instances.

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

    The factory for `Modifiers` instances.

    The factory for `Modifiers` instances.

    Definition Classes
      Trees
76.  implicit val ModifiersTag: ClassTag[Modifiers]
    Definition Classes
      Trees
77.  implicit val ModuleDefTag: ClassTag[ModuleDef]
    Definition Classes
      Trees
78.  implicit val ModuleSymbolTag: ClassTag[ModuleSymbol]
    Definition Classes
      Symbols
79.  implicit val NameTag: ClassTag[Name]
    Definition Classes
      Names
80.  implicit val NameTreeTag: ClassTag[NameTree]
    Definition Classes
      Trees
81.  implicit val NamedArgTag: ClassTag[NamedArg]
    Definition Classes
      Trees
82.  def New(sym: Symbol, args: Tree*): Tree

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

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

    Definition Classes
      Trees → Trees
83.  def New(tpe: Type, argss: List[List[Tree]]): Tree
    Definition Classes
      Trees
84.  def New(tpe: Type, args: Tree*): Tree

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

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

    Definition Classes
      Trees → Trees
85.  def New(tpt: Tree, argss: List[List[Tree]]): Tree

    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 → Trees
86.  def NewFromConstructor(constructor: Symbol, args: Tree*): Apply
    Definition Classes
      Trees
87.  implicit val NewTag: ClassTag[New]
    Definition Classes
      Trees
88.  val NoFlags: FlagSet

    The empty set of flags

    The empty set of flags

    Definition Classes
      FlagSets → FlagSets
89.  val NoKindErrors: KindErrors
    Definition Classes
      Kinds
90.  lazy val NoMods: Modifiers

    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
91.  final val NoPeriod: Int(0)
    Definition Classes
      SymbolTable
92.  val NoPosition: internal.util.NoPosition.type

    A special "missing" position.

    A special "missing" position.

    Definition Classes
      Positions → Positions
93.  final val NoRunId: Int(0)
    Definition Classes
      SymbolTable
94.  lazy val NoSymbol: NoSymbol

    A special "missing" symbol.

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

    Definition Classes
      Symbols → Symbols
95.  final val NoTag: Int(0)
    Definition Classes
      Constants
96.  final val NullTag: Int(11)
    Definition Classes
      Constants
97.  implicit val NullaryMethodTypeTag: ClassTag[NullaryMethodType]
    Definition Classes
      Types
98.  implicit val PackageDefTag: ClassTag[PackageDef]
    Definition Classes
      Trees
99.  def PerRunReporting: PerRunReporting
    Attributes
      protected
    Definition Classes
      JavaUniverse → Reporting
100.  implicit val PolyTypeTag: ClassTag[PolyType]
     Definition Classes
       Types
101.  implicit val PositionTag: ClassTag[Position]
     Definition Classes
       Positions
102.  implicit val RefTreeTag: ClassTag[RefTree]
     Definition Classes
       Trees
103.  implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
     Definition Classes
       Trees
104.  implicit val RefinedTypeTag: ClassTag[RefinedType]
     Definition Classes
       Types
105.  implicit val ReturnTag: ClassTag[Return]
     Definition Classes
       Trees
106.  implicit val RuntimeClassTag: ClassTag[RuntimeClass]
     Definition Classes
       JavaUniverse → ImplicitTags
107.  implicit val ScopeTag: ClassTag[Scope]
     Definition Classes
       Scopes
108.  def Select(qualifier: Tree, sym: Symbol): Select

     A factory method for `Select` nodes.

     A factory method for `Select` nodes.

     Definition Classes
       Trees → Trees
109.  def Select(qualifier: Tree, name: String): Select

     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 → Trees
110.  implicit val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]
     Definition Classes
       Trees
111.  implicit val SelectTag: ClassTag[Select]
     Definition Classes
       Trees
112.  final val ShortTag: Int(4)
     Definition Classes
       Constants
113.  implicit val SingleTypeTag: ClassTag[SingleType]
     Definition Classes
       Types
114.  implicit val SingletonTypeTag: ClassTag[SingletonType]
     Definition Classes
       Types
115.  implicit val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]
     Definition Classes
       Trees
116.  implicit val StarTag: ClassTag[Star]
     Definition Classes
       Trees
117.  final val StringTag: Int(10)
     Definition Classes
       Constants
118.  def Super(sym: Symbol, mix: TypeName): Tree

     A factory method for `Super` nodes.

     A factory method for `Super` nodes.

     Definition Classes
       Trees → Trees
119.  def SuperSelect(clazz: Symbol, sym: Symbol): Tree

     Creates a tree that selects a specific member `sym` without having to qualify the `super`.

     Creates a tree that selects a specific member `sym` without having to qualify the `super`. For example, given traits `B <:< A`, a class `C <:< B` needs to invoke `A.$init$`. If `A` is not a direct parent, a tree `super[A].$init$` would not type check ("does not name a parent"). So we generate `super.$init$` and pre-assign the correct symbol. A special-case in `typedSelectInternal` assigns the correct type `A` to the `super` qualifier.

     Definition Classes
       Trees
120.  implicit val SuperTag: ClassTag[Super]
     Definition Classes
       Trees
121.  implicit val SuperTypeTag: ClassTag[SuperType]
     Definition Classes
       Types
122.  implicit val SymTreeTag: ClassTag[SymTree]
     Definition Classes
       Trees
123.  implicit val SymbolTag: ClassTag[Symbol]
     Definition Classes
       Symbols
124.  def Template(sym: Symbol, body: List[Tree]): Template

     sym

       the template's symbol

     body

       trees that constitute the body of the template

     returns

       the template

     Definition Classes
       Trees
125.  implicit val TemplateTag: ClassTag[Template]
     Definition Classes
       Trees
126.  implicit val TermNameTag: ClassTag[TermName]
     Definition Classes
       Names
127.  implicit val TermSymbolTag: ClassTag[TermSymbol]
     Definition Classes
       Symbols
128.  implicit val TermTreeTag: ClassTag[TermTree]
     Definition Classes
       Trees
129.  def This(sym: Symbol): Tree

     A factory method for `This` nodes.

     A factory method for `This` nodes.

     Definition Classes
       Trees → Trees
130.  implicit val ThisTag: ClassTag[This]
     Definition Classes
       Trees
131.  implicit val ThisTypeTag: ClassTag[ThisType]
     Definition Classes
       Types
132.  def Throw(tpe: Type, args: Tree*): Throw

     A factory method for `Throw` nodes.

     A factory method for `Throw` nodes.

     Definition Classes
       Trees → Trees
133.  implicit val ThrowTag: ClassTag[Throw]
     Definition Classes
       Trees
134.  implicit val TreeCopierTag: ClassTag[TreeCopier]
     Definition Classes
       JavaUniverse → ImplicitTags
135.  implicit val TreeTag: ClassTag[Tree]
     Definition Classes
       Trees
136.  def Try(body: Tree, cases: (Tree, Tree)*): Try

     A factory method for `Try` nodes.

     A factory method for `Try` nodes.

     Definition Classes
       Trees → Trees
137.  implicit val TryTag: ClassTag[Try]
     Definition Classes
       Trees
138.  implicit val TypTreeTag: ClassTag[TypTree]
     Definition Classes
       Trees
139.  implicit val TypeApplyTag: ClassTag[TypeApply]
     Definition Classes
       Trees
140.  implicit val TypeBoundsTag: ClassTag[TypeBounds]
     Definition Classes
       Types
141.  def TypeBoundsTree(sym: Symbol): TypeBoundsTree
     Definition Classes
       Trees
142.  def TypeBoundsTree(bounds: TypeBounds): TypeBoundsTree
     Definition Classes
       Trees
143.  implicit val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]
     Definition Classes
       Trees
144.  implicit val TypeDefTag: ClassTag[TypeDef]
     Definition Classes
       Trees
145.  implicit val TypeNameTag: ClassTag[TypeName]
     Definition Classes
       Names
146.  implicit val TypeRefTag: ClassTag[TypeRef]
     Definition Classes
       Types
147.  implicit val TypeSymbolTag: ClassTag[TypeSymbol]
     Definition Classes
       Symbols
148.  implicit val TypeTagg: ClassTag[Type]
     Definition Classes
       Types
149.  def TypeTree(tp: Type): TypeTree

     A factory method for `TypeTree` nodes.

     A factory method for `TypeTree` nodes.

     Definition Classes
       Trees → Trees
150.  implicit val TypeTreeTag: ClassTag[TypeTree]
     Definition Classes
       Trees
151.  implicit val TypedTag: ClassTag[Typed]
     Definition Classes
       Trees
152.  implicit val UnApplyTag: ClassTag[UnApply]
     Definition Classes
       Trees
153.  final val UnitTag: Int(1)
     Definition Classes
       Constants
154.  implicit val ValDefTag: ClassTag[ValDef]
     Definition Classes
       Trees
155.  implicit val ValOrDefDefTag: ClassTag[ValOrDefDef]
     Definition Classes
       Trees
156.  def abort(msg: String): Nothing
     Definition Classes
       Reporting
157.  def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree
     Definition Classes
       AnnotationCheckers
158.  def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds]

     Definition Classes
       AnnotationCheckers
     See also

       AnnotationChecker.adaptBoundsToAnnotations

159.  def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type
     Definition Classes
       AnnotationCheckers
160.  def addAnnotationChecker(checker: AnnotationChecker): Unit

     Register an annotation checker.

     Register an annotation checker. Typically these are added by compiler plugins.

     Definition Classes
       AnnotationCheckers
161.  def addAnnotations(tree: Tree, tpe: Type): Type
     Definition Classes
       AnnotationCheckers
162.  implicit def addFlagOps(left: FlagSet): FlagOps

     The API of `FlagSet` instances.

     The API of `FlagSet` instances.

     Definition Classes
       FlagSets → FlagSets
163.  def addMember(thistp: Type, tp: Type, sym: Symbol, depth: Depth): Unit

     Make symbol `sym` a member of scope `tp.decls` where `thistp` is the narrowed owner type of the scope.

     Make symbol `sym` a member of scope `tp.decls` where `thistp` is the narrowed owner type of the scope.

     Definition Classes
       Types
164.  def addMember(thistp: Type, tp: Type, sym: Symbol): Unit
     Definition Classes
       Types
165.  def addSerializable(ps: Type*): List[Type]
     Definition Classes
       Types
166.  final def allNames(): Iterator[TermName]
     Definition Classes
       Names
167.  def annotatedType(annots: List[AnnotationInfo], underlying: Type): Type

     Creator for AnnotatedTypes.

     Creator for AnnotatedTypes. It returns the underlying type if annotations.isEmpty rather than walking into the assertion.

     Definition Classes
       Types
168.  def annotationToTree(ann: Annotation): Tree
     Attributes
       protected[scala]
     Definition Classes
       AnnotationInfos → Annotations
169.  def annotationsConform(tp1: Type, tp2: Type): Boolean

     Definition Classes
       AnnotationCheckers
     See also

       AnnotationChecker.annotationsConform

170.  def annotationsGlb(tpe: Type, ts: List[Type]): Type

     Definition Classes
       AnnotationCheckers
     See also

       AnnotationChecker.annotationsGlb

171.  def annotationsLub(tpe: Type, ts: List[Type]): Type

     Definition Classes
       AnnotationCheckers
     See also

       AnnotationChecker.annotationsLub

172.  def appliedType(tyconSym: Symbol, args: Type*): Type

     Very convenient.

     Very convenient.

     Definition Classes
       Types → Types
173.  def appliedType(tyconSym: Symbol, args: List[Type]): Type

     Definition Classes
       Types → Types
     See also

       appliedType

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

     Definition Classes
       Types → Types
     See also

       appliedType

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

     A creator for type applications

     A creator for type applications

     Definition Classes
       Types → Types
176.  def arrayToRepeated(tp: Type): Type

     Convert array parameters denoting a repeated parameter of a Java method to `JavaRepeatedParamClass` types.

     Convert array parameters denoting a repeated parameter of a Java method to `JavaRepeatedParamClass` types.

     Definition Classes
       SymbolTable
177.  final def asInstanceOf[T0]: T0
     Definition Classes
       Any
178.  final def assert(assertion: Boolean, message: => Any): Unit
     Definition Classes
       SymbolTable
     Annotations
       @inline()
179.  def assertCorrectThread(): Unit

     Check that the executing thread is the compiler thread.

     Check that the executing thread is the compiler thread. No-op here, overridden in interactive.Global.

     Definition Classes
       SymbolTable
     Annotations
       @elidable()
180.  final def atPhaseStack: List[Phase]
     Definition Classes
       SymbolTable
181.  def atPhaseStackMessage: String
     Definition Classes
       SymbolTable
182.  def atPos[T <: Tree](pos: Position)(tree: T): tree.type

     Position a tree.

     Position a tree. This means: Set position of a node and position all its unpositioned children.

     Definition Classes
       Positions → Positions
183.  def backquotedPath(t: Tree): String

     Turns a path into a String, introducing backquotes as necessary.

     Turns a path into a String, introducing backquotes as necessary.

     Definition Classes
       Printers
184.  def baseTypeSingletonSeq(tp: Type): BaseTypeSeq

     Create a base type sequence consisting of a single type

     Create a base type sequence consisting of a single type

     Definition Classes
       BaseTypeSeqs
185.  def basetypeRecursions: Int
     Definition Classes
       SynchronizedTypes → Types
186.  def basetypeRecursions_=(value: Int): Unit
     Definition Classes
       SynchronizedTypes → Types
187.  final def bitSetByPredicate[A](xs: List[A])(pred: (A) => Boolean): BitSet
     Definition Classes
       Collections
188.  val build: ReificationSupportImpl
     Definition Classes
       ReificationSupport
189.  def canAdaptAnnotations(tree: Tree, mode: Mode, pt: Type): Boolean
     Definition Classes
       AnnotationCheckers
190.  def captureVariable(vble: Symbol): Unit

     Mark a variable as captured; i.e.

     Mark a variable as captured; i.e. force boxing in a *Ref type.

     Definition Classes
       CapturedVariables
191.  def capturedVariableType(vble: Symbol, tpe: Type = NoType, erasedTypes: Boolean = false): Type

     Convert type of a captured variable to *Ref type.

     Convert type of a captured variable to *Ref type.

     Definition Classes
       CapturedVariables
192.  def capturedVariableType(vble: Symbol): Type

     Convert type of a captured variable to *Ref type.

     Convert type of a captured variable to *Ref type.

     Definition Classes
       CapturedVariables
193.  def changeNonLocalOwners(tree: Tree, newowner: Symbol): Unit
     Definition Classes
       Trees
194.  def checkKindBounds0(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol, explainErrors: Boolean): List[(Type, Symbol, KindErrors)]

     Check well-kindedness of type application (assumes arities are already checked) -- @M

     Check well-kindedness of type application (assumes arities are already checked) -- @M

     This check is also performed when abstract type members become concrete (aka a "type alias") -- then tparams.length==1 (checked one type member at a time -- in that case, prefix is the name of the type alias)

     Type application is just like value application: it's "contravariant" in the sense that the type parameters of the supplied type arguments must conform to the type parameters of the required type parameters:

     - their bounds must be less strict
     - variances must match (here, variances are absolute, the variance of a type parameter does not influence the variance of its higher-order parameters)
     - @M TODO: are these conditions correct,sufficient&necessary?

     e.g. class Iterable[t, m[+x <: t]] --> the application Iterable[Int, List] is okay, since List's type parameter is also covariant and its bounds are weaker than <: Int

     Definition Classes
       Kinds
     Annotations
       @nowarn()
195.  def clone(): AnyRef
     Attributes
       protected[lang]
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.CloneNotSupportedException]) @native()
196.  def cloneSymbols(syms: List[Symbol]): List[Symbol]

     Convenience functions which derive symbols by cloning.

     Convenience functions which derive symbols by cloning.

     Definition Classes
       Symbols
197.  def cloneSymbolsAndModify(syms: List[Symbol], infoFn: (Type) => Type): List[Symbol]

     Clone symbols and apply the given function to each new symbol's info.

     Clone symbols and apply the given function to each new symbol's info.

     syms

       the prototypical symbols

     infoFn

       the function to apply to the infos

     returns

       the newly created, info-adjusted symbols

     Definition Classes
       Symbols
198.  def cloneSymbolsAtOwner(syms: List[Symbol], owner: Symbol): List[Symbol]
     Definition Classes
       Symbols
199.  def cloneSymbolsAtOwnerAndModify(syms: List[Symbol], owner: Symbol, infoFn: (Type) => Type): List[Symbol]
     Definition Classes
       Symbols
200.  final def closestEnclMethod(from: Symbol): Symbol

     Return closest enclosing method, unless shadowed by an enclosing class.

     Return closest enclosing method, unless shadowed by an enclosing class.

     Definition Classes
       Symbols
     Annotations
       @tailrec()
201.  final def collectFirst[A, B](as: List[A])(pf: PartialFunction[A, B]): Option[B]
     Definition Classes
       Collections
202.  final def collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) => Boolean): Map[A, B]
     Definition Classes
       Collections
203.  def commonOwner(tps: List[Type]): Symbol

     The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given list of types.

     The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given list of types.

     Attributes
       protected[reflect.internal]
     Definition Classes
       CommonOwners
204.  def commonOwner(t: Type): Symbol

     The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given type.

     The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given type.

     Attributes
       protected[reflect.internal]
     Definition Classes
       CommonOwners
205.  def commonOwnerMap: CommonOwnerMap
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → CommonOwners
206.  final def compareLengths(xs1: List[_], xs2: List[_]): Int
     Definition Classes
       Collections
     Annotations
       @tailrec()
207.  def compoundBaseTypeSeq(tp: Type): BaseTypeSeq

     Create the base type sequence of a compound type with given tp.parents

     Create the base type sequence of a compound type with given tp.parents

     Definition Classes
       BaseTypeSeqs
208.  def computeBaseClasses(tpe: Type): List[Symbol]
     Attributes
       protected
     Definition Classes
       Types
209.  def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): m.type
     Definition Classes
       SynchronizedSymbols → Symbols
210.  def containsExistential(tpe: Type): Boolean
     Definition Classes
       Types
211.  def copyClassDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, impl: Template = null): ClassDef
     Definition Classes
       Trees
212.  def copyDefDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, vparamss: List[List[ValDef]] = null, tpt: Tree = null, rhs: Tree = null): DefDef
     Definition Classes
       Trees
213.  def copyMethodType(tp: Type, params: List[Symbol], restpe: Type): Type

     Create a new MethodType

     Create a new MethodType

     Definition Classes
       Types
214.  def copyModuleDef(tree: Tree)(mods: Modifiers = null, name: Name = null, impl: Template = null): ModuleDef
     Definition Classes
       Trees
215.  def copyRefinedType(original: RefinedType, parents: List[Type], decls: Scope, owner: Symbol = null): Type
     Definition Classes
       Types
216.  def copyTypeDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, rhs: Tree = null): TypeDef
     Definition Classes
       Trees
217.  def copyTypeRef(tp: Type, pre: Type, sym: Symbol, args: List[Type]): Type
     Definition Classes
       Types
218.  def copyValDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tpt: Tree = null, rhs: Tree = null): ValDef
     Definition Classes
       Trees
219.  final def corresponds3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean

     True if all three arguments have the same number of elements and the function is true for all the triples.

     True if all three arguments have the same number of elements and the function is true for all the triples.

     Definition Classes
       Collections
     Annotations
       @tailrec()
220.  def createFromClonedSymbols[T](syms: List[Symbol], tpe: Type)(creator: (List[Symbol], Type) => T): T

     Functions which perform the standard clone/substituting on the given symbols and type, then call the creator function with the new symbols and type as arguments.

     Functions which perform the standard clone/substituting on the given symbols and type, then call the creator function with the new symbols and type as arguments.

     Definition Classes
       Symbols
221.  def createFromClonedSymbolsAtOwner[T](syms: List[Symbol], owner: Symbol, tpe: Type)(creator: (List[Symbol], Type) => T): T
     Definition Classes
       Symbols
222.  def currentFreshNameCreator: FreshNameCreator
     Definition Classes
       JavaUniverse → FreshNames
223.  final def currentPeriod: Period

     The current period.

     The current period.

     Definition Classes
       SymbolTable
224.  def currentRun: RunReporting
     Definition Classes
       JavaUniverse → Reporting
225.  val currentRunId: Int

     The current compiler run identifier.

     The current compiler run identifier.

     Definition Classes
       ReflectSetup → SymbolTable
226.  def currentRunProfilerAfterCompletion(root: Symbol, associatedFile: AbstractFile): Unit
     Attributes
       protected[scala]
     Definition Classes
       SymbolTable
227.  def currentRunProfilerBeforeCompletion(root: Symbol, associatedFile: AbstractFile): Unit
     Attributes
       protected[scala]
     Definition Classes
       SymbolTable
228.  def debugInfo(msg: => String): Unit
     Definition Classes
       SymbolTable
229.  def debugStack(t: Throwable): Unit

     Prints a stack trace if -Ydebug or equivalent was given, otherwise does nothing.

     Prints a stack trace if -Ydebug or equivalent was given, otherwise does nothing.

     Definition Classes
       SymbolTable
230.  def debugString(tp: Type): String
     Definition Classes
       TypeDebugging
231.  def debuglog(msg: => String): Unit

     Override with final implementation for inlining.

     Override with final implementation for inlining.

     Definition Classes
       SymbolTable
232.  def decodedSymName(tree: Tree, name: Name): String
     Definition Classes
       Printers
233.  def defineBaseClassesOfCompoundType(tpe: CompoundType): Unit
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → Types
234.  def defineBaseTypeSeqOfCompoundType(tpe: CompoundType): Unit
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → Types
235.  def defineBaseTypeSeqOfTypeRef(tpe: TypeRef): Unit
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → Types
236.  def defineNormalized(tr: TypeRef): Unit
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → Types
237.  def defineOriginalOwner(sym: Symbol, owner: Symbol): Unit
     Definition Classes
       Symbols
238.  def defineParentsOfTypeRef(tpe: TypeRef): Unit
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → Types
239.  def defineUnderlyingOfSingleType(tpe: SingleType): Unit
     Attributes
       protected
     Definition Classes
       SynchronizedTypes → Types
240.  def deriveCaseDef(cdef: Tree)(applyToBody: (Tree) => Tree): CaseDef
     Definition Classes
       Trees
241.  def deriveClassDef(cdef: Tree)(applyToImpl: (Template) => Template): ClassDef
     Definition Classes
       Trees
242.  def deriveDefDef(ddef: Tree)(applyToRhs: (Tree) => Tree): DefDef
     Definition Classes
       Trees
243.  def deriveFreshSkolems(tparams: List[Symbol]): List[Symbol]

     Map a list of type parameter symbols to skolemized symbols, which can be deskolemized to the original type parameter.

     Map a list of type parameter symbols to skolemized symbols, which can be deskolemized to the original type parameter. (A skolem is a representation of a bound variable when viewed inside its scope.) !!!Adriaan: this does not work for hk types.

     Skolems will be created at level 0, rather than the current value of `skolemizationLevel`. (See scala/bug#7782)

     Definition Classes
       ExistentialsAndSkolems
244.  def deriveFunction(func: Tree)(applyToRhs: (Tree) => Tree): Function
     Definition Classes
       Trees
245.  def deriveLabelDef(ldef: Tree)(applyToRhs: (Tree) => Tree): LabelDef
     Definition Classes
       Trees
246.  def deriveModuleDef(mdef: Tree)(applyToImpl: (Template) => Template): ModuleDef
     Definition Classes
       Trees
247.  def deriveSymbols(syms: List[Symbol], symFn: (Symbol) => Symbol): List[Symbol]

     Derives a new list of symbols from the given list by mapping the given list across the given function.

     Derives a new list of symbols from the given list by mapping the given list across the given function. Then fixes the info of all the new symbols by substituting the new symbols for the original symbols.

     syms

       the prototypical symbols

     symFn

       the function to create new symbols

     returns

       the new list of info-adjusted symbols

     Definition Classes
       Symbols
248.  def deriveSymbols2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) => Symbol): List[Symbol]

     Derives a new list of symbols from the given list by mapping the given list of `syms` and `as` across the given function.

     Derives a new list of symbols from the given list by mapping the given list of `syms` and `as` across the given function. Then fixes the info of all the new symbols by substituting the new symbols for the original symbols.

     syms

       the prototypical symbols

     as

       arguments to be passed to symFn together with symbols from syms (must be same length)

     symFn

       the function to create new symbols

     returns

       the new list of info-adjusted symbols

     Definition Classes
       Symbols
249.  def deriveTemplate(templ: Tree)(applyToBody: (List[Tree]) => List[Tree]): Template
     Definition Classes
       Trees
250.  def deriveType(syms: List[Symbol], symFn: (Symbol) => Symbol)(tpe: Type): Type

     Derives a new Type by first deriving new symbols as in deriveSymbols, then performing the same oldSyms => newSyms substitution on `tpe` as is performed on the symbol infos in deriveSymbols.

     Derives a new Type by first deriving new symbols as in deriveSymbols, then performing the same oldSyms => newSyms substitution on `tpe` as is performed on the symbol infos in deriveSymbols.

     syms

       the prototypical symbols

     symFn

       the function to create new symbols

     tpe

       the prototypical type

     returns

       the new symbol-substituted type

     Definition Classes
       Symbols
251.  def deriveType2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) => Symbol)(tpe: Type): Type

     Derives a new Type by first deriving new symbols as in deriveSymbols2, then performing the same oldSyms => newSyms substitution on `tpe` as is performed on the symbol infos in deriveSymbols.

     Derives a new Type by first deriving new symbols as in deriveSymbols2, then performing the same oldSyms => newSyms substitution on `tpe` as is performed on the symbol infos in deriveSymbols.

     syms

       the prototypical symbols

     as

       arguments to be passed to symFn together with symbols from syms (must be same length)

     symFn

       the function to create new symbols based on `as`

     tpe

       the prototypical type

     returns

       the new symbol-substituted type

     Definition Classes
       Symbols
252.  def deriveTypeWithWildcards(syms: List[Symbol])(tpe: Type): Type

     Derives a new Type by instantiating the given list of symbols as WildcardTypes.

     Derives a new Type by instantiating the given list of symbols as WildcardTypes.

     syms

       the symbols to replace

     returns

       the new type with WildcardType replacing those syms

     Definition Classes
       Symbols
253.  def deriveValDef(vdef: Tree)(applyToRhs: (Tree) => Tree): ValDef
     Definition Classes
       Trees
254.  def devWarning(msg: => String): Unit
     Definition Classes
       SymbolTable
255.  final def devWarningDumpStack(msg: => String, maxFrames: Int): Unit
     Definition Classes
       SymbolTable
     Annotations
       @inline()
256.  final def devWarningIf(cond: => Boolean)(msg: => String): Unit

     dev-warns if dev-warning is enabled and `cond` is true; no-op otherwise

     dev-warns if dev-warning is enabled and `cond` is true; no-op otherwise

     Definition Classes
       SymbolTable
     Annotations
       @inline()
257.  final def distinctBy[A, B](xs: List[A])(f: (A) => B): List[A]
     Definition Classes
       Collections
258.  def duplicateAndKeepPositions(tree: Tree): Tree
     Definition Classes
       Trees
259.  def elapsedMessage(msg: String, startNs: Long): String
     Attributes
       protected
     Definition Classes
       SymbolTable
260.  def elementExtract(container: Symbol, tp: Type): Type
     Definition Classes
       Types
261.  def elementExtractOption(container: Symbol, tp: Type): Option[Type]
     Definition Classes
       Types
262.  def elementTest(container: Symbol, tp: Type)(f: (Type) => Boolean): Boolean
     Definition Classes
       Types
263.  def elementTransform(container: Symbol, tp: Type)(f: (Type) => Type): Type
     Definition Classes
       Types
264.  def elimAnonymousClass(t: Type): Type
     Definition Classes
       Types
265.  def encode(str: String): TermName
     Definition Classes
       StdNames
266.  def ensureNonOverlapping(tree: Tree, others: List[Tree], focus: Boolean): Unit
     Definition Classes
       Positions
267.  def ensureNonOverlapping(tree: Tree, others: List[Tree]): Unit

     Ensure that given tree has no positions that overlap with any of the positions of `others`.

     Ensure that given tree has no positions that overlap with any of the positions of `others`. This is done by shortening the range, assigning TransparentPositions to some of the nodes in `tree` or focusing on the position.

     Definition Classes
       Positions
268.  def ensuring(cond: (JavaUniverse) => Boolean, msg: => Any): JavaUniverse
     Implicit
       This member is added by an implicit conversion from JavaUniverse toEnsuring[JavaUniverse] performed by method Ensuring in scala.Predef.
     Definition Classes
       Ensuring
269.  def ensuring(cond: (JavaUniverse) => Boolean): JavaUniverse
     Implicit
       This member is added by an implicit conversion from JavaUniverse toEnsuring[JavaUniverse] performed by method Ensuring in scala.Predef.
     Definition Classes
       Ensuring
270.  def ensuring(cond: Boolean, msg: => Any): JavaUniverse
     Implicit
       This member is added by an implicit conversion from JavaUniverse toEnsuring[JavaUniverse] performed by method Ensuring in scala.Predef.
     Definition Classes
       Ensuring
271.  def ensuring(cond: Boolean): JavaUniverse
     Implicit
       This member is added by an implicit conversion from JavaUniverse toEnsuring[JavaUniverse] performed by method Ensuring in scala.Predef.
     Definition Classes
       Ensuring
272.  final def enteringPhase[T](ph: Phase)(op: => T): T

     Perform given operation at given phase.

     Perform given operation at given phase.

     Definition Classes
       SymbolTable
     Annotations
       @inline()
273.  final def enteringPhaseNotLaterThan[T](target: Phase)(op: => T): T
     Definition Classes
       SymbolTable
     Annotations
       @inline()
274.  final def enteringPhaseWithName[T](phaseName: String)(body: => T): T
     Definition Classes
       SymbolTable
275.  final def enteringPrevPhase[T](op: => T): T
     Definition Classes
       SymbolTable
     Annotations
       @inline()
276.  final def eq(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
277.  def equals(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef → Any
278.  def erasure: Erasure { val global: JavaUniverse.this.type }
     Definition Classes
       Transforms
279.  def erasurePhase: SomePhase
     Definition Classes
       JavaUniverse → SymbolTable
280.  def existentialAbstraction(tparams: List[Symbol], tpe0: Type, flipVariance: Boolean = false): Type

     A creator for existential types.

     A creator for existential types. This generates:

     tpe1 where { tparams }

     where `tpe1` is the result of extrapolating `tpe` with respect to `tparams`. Extrapolating means that type variables in `tparams` occurring in covariant positions are replaced by upper bounds, (minus any SingletonClass markers), type variables in `tparams` occurring in contravariant positions are replaced by upper bounds, provided the resulting type is legal with regard to stability, and does not contain any type variable in `tparams`.

     The abstraction drops all type parameters that are not directly or indirectly referenced by type `tpe1`. If there are no remaining type parameters, simply returns result type `tpe`.

     Definition Classes
       Types
281.  final def existentialTransform[T](rawSyms: List[Symbol], tp: Type, rawOwner: Symbol = NoSymbol)(creator: (List[Symbol], Type) => T): T

     Given a set `rawSyms` of term- and type-symbols, and a type `tp`, produce a set of fresh type parameters and a type so that it can be abstracted to an existential type.

     Given a set `rawSyms` of term- and type-symbols, and a type `tp`, produce a set of fresh type parameters and a type so that it can be abstracted to an existential type. Every type symbol `T` in `rawSyms` is mapped to a clone. Every term symbol `x` of type `T` in `rawSyms` is given an associated type symbol of the following form:

     type x.type <: T with Singleton

     The name of the type parameter is `x.type`, to produce nice diagnostics. The Singleton parent ensures that the type parameter is still seen as a stable type. Type symbols in rawSyms are fully replaced by the new symbols. Term symbols are also replaced, except for term symbols of an Ident tree, where only the type of the Ident is changed.

     Definition Classes
       ExistentialsAndSkolems
282.  def existentialsInType(tpe: Type): List[Symbol]
     Definition Classes
       Types
283.  def existingSymbols(syms: List[Symbol]): List[Symbol]
     Definition Classes
       Symbols
284.  final def exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) => Boolean): Boolean
     Definition Classes
       Collections
285.  final def exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean
     Definition Classes
       Collections
286.  final def exitingPhase[T](ph: Phase)(op: => T): T
     Definition Classes
       SymbolTable
     Annotations
       @inline()
287.  def explain[T](op: String, p: (Type, T) => Boolean, tp1: Type, arg2: T): Boolean

     Perform operation `p` on arguments `tp1`, `arg2` and print trace of computation.

     Perform operation `p` on arguments `tp1`, `arg2` and print trace of computation.

     Attributes
       protected
     Definition Classes
       Types
288.  def explainTypes(op: (Type, Type) => Any, found: Type, required: Type): Unit

     If option `explaintypes` is set, print a subtype trace for `op(found, required)`.

     If option `explaintypes` is set, print a subtype trace for `op(found, required)`.

     Definition Classes
       Types
289.  def explainTypes(found: Type, required: Type): Unit

     If option `explaintypes` is set, print a subtype trace for `found <:< required`.

     If option `explaintypes` is set, print a subtype trace for `found <:< required`.

     Definition Classes
       Types
290.  def explicitlyUnit(tree: Tree): Boolean
     Definition Classes
       StdAttachments
291.  def extensionMethInfo(currentOwner: Symbol, extensionMeth: Symbol, origInfo: Type, clazz: Symbol): Type

     We will need to clone the info of the original method (which obtains clones of the method type parameters), clone the type parameters of the value class, and create a new polymethod with the union of all those type parameters, with their infos adjusted to be consistent with their new home.

     We will need to clone the info of the original method (which obtains clones of the method type parameters), clone the type parameters of the value class, and create a new polymethod with the union of all those type parameters, with their infos adjusted to be consistent with their new home. Example:

     class Foo[+A <: AnyRef](val xs: List[A]) extends AnyVal { def baz[B >: A](x: B): List[B] = x :: xs // baz has to be transformed into this extension method, where // A is cloned from class Foo and B is cloned from method baz: // def extension$baz[B >: A <: Any, A >: Nothing <: AnyRef]($this: Foo[A])(x: B): List[B] }

     TODO: factor out the logic for consolidating type parameters from a class and a method for re-use elsewhere, because nobody will get this right without some higher level facilities.

     Definition Classes
       Types
292.  final def fillList[T](n: Int)(t: T): List[T]
     Definition Classes
       Collections
293.  def finalize(): Unit
     Attributes
       protected[lang]
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.Throwable])
294.  final def findOrElse[A](xs: IterableOnce[A])(p: (A) => Boolean)(orElse: => A): A
     Definition Classes
       Collections
295.  final def findPhaseWithName(phaseName: String): Phase
     Definition Classes
       SymbolTable
296.  final def findSymbol(xs: IterableOnce[Symbol])(p: (Symbol) => Boolean): Symbol
     Definition Classes
       SymbolTable
     Annotations
       @inline()
297.  final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Iterable[B]]): List[B]
     Definition Classes
       Collections
298.  final def flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) => List[C]): List[C]
     Definition Classes
       Collections
299.  final def flattensToEmpty(xss: Seq[Seq[_]]): Boolean
     Definition Classes
       Collections
     Annotations
       @tailrec()
300.  final def focusInPlace(t: Tree): t.type
     Definition Classes
       Trees
301.  final def foldLeft2[A1, A2, B](xs1: List[A1], xs2: List[A2])(z0: B)(f: (B, A1, A2) => B): B
     Definition Classes
       Collections
302.  final def forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean
     Definition Classes
       Collections
303.  def force(): Unit
     Definition Classes
       JavaUniverseForce
304.  final def foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) => Unit): Unit
     Definition Classes
       Collections
305.  final def foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Unit): Unit
     Definition Classes
       Collections
306.  def foreachParamss(sym: Symbol)(f: (Symbol) => Unit): Unit
     Definition Classes
       Symbols
307.  final def foreachWithIndex[A](xs: List[A])(f: (A, Int) => Unit): Unit
     Definition Classes
       Collections
308.  def freshExistentialName(suffix: String, id: Int): TypeName
     Attributes
       protected
     Definition Classes
       Symbols
309.  def freshTermName(prefix: String = nme.FRESH_TERM_NAME_PREFIX)(implicit creator: FreshNameCreator): TermName
     Definition Classes
       FreshNames
310.  def freshTypeName(prefix: String)(implicit creator: FreshNameCreator): TypeName
     Definition Classes
       FreshNames
311.  val gen: internal.TreeGen { val global: JavaUniverse.this.type }
     Definition Classes
       SymbolTable
312.  def genPolyType(params: List[Symbol], tpe: Type): Type
     Definition Classes
       Types
313.  final def getClass(): Class[_ <: AnyRef]
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
314.  def getCurrentSymbolIdCount: Int
     Definition Classes
       Symbols
315.  final def gilSynchronized[T](body: => T): T
     Definition Classes
       Gil
     Annotations
       @inline()
316.  def glb(ts: List[Type], depth: Depth): Type
     Attributes
       protected[reflect.internal]
     Definition Classes
       GlbLubs
317.  def glb(ts: List[Type]): Type

     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
       GlbLubs
318.  def glbNorm(ts0: List[Type], depth: Depth): Type

     The greatest lower bound of a list of types (as determined by `<:<`), which have been normalized with regard to `elimSuper`.

     The greatest lower bound of a list of types (as determined by `<:<`), which have been normalized with regard to `elimSuper`.

     Attributes
       protected
     Definition Classes
       GlbLubs
319.  def glbResults: HashMap[(Depth, List[Type]), Type]
     Definition Classes
       SynchronizedTypes → GlbLubs
320.  def globalError(pos: Position, msg: String): Unit
     Definition Classes
       Reporting
     Annotations
       @deprecatedOverriding()
321.  def globalError(msg: String): Unit
     Definition Classes
       Reporting
     Annotations
       @deprecatedOverriding()
322.  val globalFreshNameCreator: FreshNameCreator
     Definition Classes
       FreshNames
323.  final def hasLength(xs: List[_], len: Int): Boolean

     Again avoiding calling length, but the lengthCompare interface is clunky.

     Again avoiding calling length, but the lengthCompare interface is clunky.

     Definition Classes
       Collections
324.  def hashCode(): Int
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
325.  final def howManyUniqueTypes: Int
     Definition Classes
       Types
326.  val ids: Int
     Attributes
       protected
     Definition Classes
       Symbols
327.  def importableMembers(pre: Type): Scope

     Members which can be imported into other scopes.

     Members which can be imported into other scopes.

     Definition Classes
       Types
328.  def indent: String
     Definition Classes
       SynchronizedTypes → Types
329.  def indent_=(value: String): Unit
     Definition Classes
       SynchronizedTypes → Types
330.  def info(msg: => String): Unit
     Definition Classes
       SymbolTable
331.  var infoTransformers: InfoTransformer

     The set of all installed infotransformers.

     The set of all installed infotransformers.

     Definition Classes
       SymbolTable
332.  def inform(pos: Position, msg: String): Unit
     Definition Classes
       Reporting
     Annotations
       @deprecatedOverriding()
333.  def inform(msg: String): Unit
     Definition Classes
       Reporting
     Annotations
       @deprecatedOverriding()
334.  def informProgress(msg: String): Unit
     Definition Classes
       SymbolTable
335.  def informTime(msg: String, startNs: Long): Unit
     Definition Classes
       SymbolTable
336.  final def informingProgress[T](msg: => String)(fn: => T): T
     Definition Classes
       SymbolTable
     Annotations
       @inline()
337.  def inheritsJavaVarArgsMethod(clazz: Symbol): Boolean
     Definition Classes
       Types
338.  def init(): Unit
339.  def initAndEnterClassAndModule(owner: Symbol, name: TypeName, completer: (ClassSymbol, ModuleSymbol) => LazyType): (ClassSymbol, ModuleSymbol)

     Create a class and a companion object, enter in enclosing scope, and initialize with a lazy type completer.

     Create a class and a companion object, enter in enclosing scope, and initialize with a lazy type completer.

     owner

       The owner of the newly created class and object

     name

       The simple name of the newly created class

     completer

       The completer to be used to set the info of the class and the module

     Attributes
       protected
     Definition Classes
       SymbolLoaders
340.  def initClassAndModule(clazz: Symbol, module: Symbol, completer: LazyType): Unit
     Attributes
       protected
     Definition Classes
       SymbolLoaders
341.  lazy val internal: Internal

     Definition Classes
       JavaUniverse → Internals → Internals
     See also

       InternalApi

342.  def intersectionType(tps: List[Type]): Type

     A creator for intersection type where intersections of a single type are replaced by the type itself.

     A creator for intersection type where intersections of a single type are replaced by the type itself.

     Definition Classes
       Types
343.  def intersectionType(tps: List[Type], owner: Symbol): Type

     A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.

     A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.

     !!! Repeated parent classes are not merged - is this a bug in the comment or in the code?

     Definition Classes
       Types
344.  def intersectionTypeForLazyBaseType(tps: List[Type]): Type
     Definition Classes
       Types
345.  def intersectionWitness: WeakHashMap[List[Type], WeakReference[Type]]
     Definition Classes
       SynchronizedTypes → Types
346.  def invalidateCaches(t: Type, updatedSyms: Set[Symbol]): Unit
     Definition Classes
       Types
347.  def invalidateTreeTpeCaches(tree: Tree, updatedSyms: Set[Symbol]): Unit
     Definition Classes
       Types
348.  final def isAtPhaseAfter(p: Phase): Boolean

     Are we later than given phase in compilation?

     Are we later than given phase in compilation?

     Definition Classes
       SymbolTable
349.  def isBoundedGeneric(tp: Type): Boolean
     Definition Classes
       Types
350.  def isCompilerUniverse: Boolean

     Declares that this is a runtime reflection universe.

     Declares that this is a runtime reflection universe.

     This means that we can make certain assumptions to optimize the universe. For example, we may auto-initialize symbols on flag and annotation requests (see `shouldTriggerCompleter` below for more details).

     On the other hand, this also means that usage scenarios of the universe will differ from the conventional ones. For example, we have to do additional cleanup in order to prevent memory leaks: https://groups.google.com/group/scala-internals/browse_thread/thread/eabcf3d406dab8b2.

     Definition Classes
       SymbolTable → SymbolTable
351.  def isConstantType(tp: Type): Boolean
     Definition Classes
       Types
352.  final def isDeveloper: Boolean
     Definition Classes
       SymbolTable
     Annotations
       @inline()
353.  def isDifferentType(tp1: Type, tp2: Type): Boolean
     Definition Classes
       TypeComparers
354.  def isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean
     Definition Classes
       TypeComparers
355.  final def isEligibleForPrefixUnification(tp: Type): Boolean

     Does this type have a prefix that begins with a type variable, or is it a refinement type? For type prefixes that fulfil this condition, type selections with the same name of equal (as determined by `=:=`) prefixes are considered equal in regard to `=:=`.

     Does this type have a prefix that begins with a type variable, or is it a refinement type? For type prefixes that fulfil this condition, type selections with the same name of equal (as determined by `=:=`) prefixes are considered equal in regard to `=:=`.

     Definition Classes
       Types
     Annotations
       @tailrec()
356.  def isErrorOrWildcard(tp: Type): Boolean
     Definition Classes
       Types
357.  final def isExistentialType(tp: Type): Boolean
     Definition Classes
       Types
     Annotations
       @tailrec()
358.  def isHKSubType(tp1: Type, tp2: Type, depth: Depth): Boolean
     Definition Classes
       TypeComparers
359.  def isImplicitMethodType(tp: Type): Boolean
     Definition Classes
       Types
360.  final def isInstanceOf[T0]: Boolean
     Definition Classes
       Any
361.  def isIntersectionTypeForLazyBaseType(tp: RefinedType): Boolean
     Definition Classes
       Types
362.  def isJavaVarargsAncestor(clazz: Symbol): Boolean
     Definition Classes
       Types
363.  def isNonRefinementClassType(tpe: Type): Boolean

     def isNonValueType(tp: Type) = !isValueElseNonValue(tp)

     def isNonValueType(tp: Type) = !isValueElseNonValue(tp)

     Definition Classes
       Types
364.  def isNumericSubType(tp1: Type, tp2: Type): Boolean
     Definition Classes
       TypeComparers
365.  def isPastTyper: Boolean
     Definition Classes
       SymbolTable
366.  def isPopulated(tp1: Type, tp2: Type): Boolean

     Is intersection of given types populated? That is, for all types tp1, tp2 in intersection for all common base classes bc of tp1 and tp2 let bt1, bt2 be the base types of tp1, tp2 relative to class bc Then: bt1 and bt2 have the same prefix, and any corresponding non-variant type arguments of bt1 and bt2 are the same

     Is intersection of given types populated? That is, for all types tp1, tp2 in intersection for all common base classes bc of tp1 and tp2 let bt1, bt2 be the base types of tp1, tp2 relative to class bc Then: bt1 and bt2 have the same prefix, and any corresponding non-variant type arguments of bt1 and bt2 are the same

     Definition Classes
       Types
367.  def isPossiblePrefix(clazz: Symbol): Boolean

     Might the given symbol be important when calculating the prefix of a type? When tp.asSeenFrom(pre, clazz) is called on `tp`, the result will be `tp` unchanged if `pre` is trivial and `clazz` is a symbol such that isPossiblePrefix(clazz) == false.

     Might the given symbol be important when calculating the prefix of a type? When tp.asSeenFrom(pre, clazz) is called on `tp`, the result will be `tp` unchanged if `pre` is trivial and `clazz` is a symbol such that isPossiblePrefix(clazz) == false.

     Definition Classes
       TypeMaps
368.  def isRawIfWithoutArgs(sym: Symbol): Boolean
     Definition Classes
       Types
369.  def isRawParameter(sym: Symbol): Boolean
     Definition Classes
       ExistentialsAndSkolems
370.  def isRawType(tp: Type): Boolean

     Is type tp a raw type?

     Is type tp a raw type?

     Definition Classes
       Types
371.  def isSameSymbolTypes(syms1: List[Symbol], syms2: List[Symbol]): Boolean

     Are `tps1` and `tps2` lists of pairwise equivalent symbols according to `_.tpe` ?

     Are `tps1` and `tps2` lists of pairwise equivalent symbols according to `_.tpe` ?

     Definition Classes
       Types
372.  def isSameType(tp1: Type, tp2: Type): Boolean

     Do `tp1` and `tp2` denote equivalent types?

     Do `tp1` and `tp2` denote equivalent types?

     Definition Classes
       TypeComparers
373.  def isSameType2(tp1: Type, tp2: Type): Boolean
     Definition Classes
       TypeComparers
374.  def isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean

     Are `tps1` and `tps2` lists of pairwise equivalent types?

     Are `tps1` and `tps2` lists of pairwise equivalent types?

     Definition Classes
       Types
375.  def isSingleType(tp: Type): Boolean

     This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes FoldableConstantTypes.

     This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes FoldableConstantTypes.

     Definition Classes
       Types
376.  def isSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol], depth: Depth): Boolean
     Definition Classes
       Types
377.  def isSubType(tp1: Type, tp2: Type, depth: Depth = Depth.AnyDepth): Boolean
     Definition Classes
       TypeComparers
378.  def isSymbolLockTracingEnabled: Boolean
     Definition Classes
       SymbolTable
379.  def isTreeSymbolPickled(tree: Tree): Boolean

     This method should be equivalent to tree.hasSymbolField, but that method doesn't do us any good when we're unpickling because we need to know based on the Int tag - the tree doesn't exist yet.

     This method should be equivalent to tree.hasSymbolField, but that method doesn't do us any good when we're unpickling because we need to know based on the Int tag - the tree doesn't exist yet. Thus, this method is documentation only.

     Definition Classes
       Translations
380.  def isTreeSymbolPickled(code: Int): Boolean
     Definition Classes
       Translations
381.  def isUnboundedGeneric(tp: Type): Boolean
     Definition Classes
       Types
382.  def isUseableAsTypeArg(tp: Type): Boolean

     This is defined and named as it is because the goal is to exclude source level types which are not value types (e.g.

     This is defined and named as it is because the goal is to exclude source level types which are not value types (e.g. MethodType) without excluding necessary internal types such as WildcardType. There are also non-value types which can be used as type arguments (e.g. type constructors.)

     Definition Classes
       Types
383.  final def isUseableAsTypeArgs(tps: List[Type]): Boolean
     Definition Classes
       Types
     Annotations
       @tailrec()
384.  final def isValid(period: Period): Boolean
     Definition Classes
       SymbolTable
385.  final def isValidForBaseClasses(period: Period): Boolean
     Definition Classes
       SymbolTable
386.  def isWeakSubType(tp1: Type, tp2: Type): Boolean
     Definition Classes
       TypeComparers
387.  def isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean

     Do type arguments `targs` conform to formal parameters `tparams`?

     Do type arguments `targs` conform to formal parameters `tparams`?

     Definition Classes
       Types
388.  val javanme: JavaKeywords
     Definition Classes
       StdNames
389.  var keepPhaseStack: Boolean
     Definition Classes
       SymbolTable
390.  def kindsConform(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol): Boolean
     Definition Classes
       Kinds
391.  final def linkedMapFrom[A, A1 >: A, B](xs: List[A])(f: (A) => B): LinkedHashMap[A1, B]
     Definition Classes
       Collections
392.  def lockedCount: Int
     Definition Classes
       Symbols
393.  def lockedCount_=(i: Int): Unit
     Definition Classes
       Symbols
394.  def log(msg: => AnyRef): Unit
     Definition Classes
       JavaUniverse → SymbolTable
395.  final def lookupTypeName(cs: Array[Char]): TypeName

     Used by the GenBCode backend to lookup type names that are known to already exist.

     Used by the GenBCode backend to lookup type names that are known to already exist. This method might be invoked in a multi-threaded setting. Invoking newTypeName instead might be unsafe.

     can-multi-thread: names are added to the hash tables only after they are fully constructed.

     Definition Classes
       Names
396.  implicit def lowPriorityNameOrdering[T <: Name]: Ordering[T]
     Definition Classes
       SymbolTable
397.  def lub(ts0: List[Type], depth: Depth): Type

     The least upper bound wrt <:< of a list of types

     The least upper bound wrt <:< of a list of types

     Attributes
       protected[reflect.internal]
     Definition Classes
       GlbLubs
398.  def lub(ts: List[Type]): Type
     Definition Classes
       GlbLubs
399.  def lubDepth(ts: List[Type]): Depth

     The maximum allowable depth of lubs or glbs over types `ts`.

     The maximum allowable depth of lubs or glbs over types `ts`.

     Definition Classes
       Types
400.  def lubList(ts: List[Type], depth: Depth): List[Type]

     Given a matrix `tsBts` whose columns are basetype sequences (and the symbols `tsParams` that should be interpreted as type parameters in this matrix), compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:

     Given a matrix `tsBts` whose columns are basetype sequences (and the symbols `tsParams` that should be interpreted as type parameters in this matrix), compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:

     xs <= ys iff forall y in ys exists x in xs such that x <: y

     Definition Classes
       GlbLubs
     See also

       baseTypeSeq for a definition of sorted and upwards closed.

401.  def lubResults: HashMap[(Depth, List[Type]), Type]
     Definition Classes
       SynchronizedTypes → GlbLubs
402.  def makeNoSymbol: NoSymbol
     Attributes
       protected
     Definition Classes
       SynchronizedSymbols → Symbols
403.  final def map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) => C): List[C]
     Definition Classes
       Collections
404.  final def map2Conserve[A <: AnyRef, B](xs: List[A], ys: List[B])(f: (A, B) => A): List[A]

     like map2, but returns list `xs` itself - instead of a copy - if function `f` maps all elements to themselves.

     like map2, but returns list `xs` itself - instead of a copy - if function `f` maps all elements to themselves.

     Definition Classes
       Collections
405.  final def map3[A, B, C, D](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => D): List[D]
     Definition Classes
       Collections
406.  final def mapFilter2[A, B, C](itA: Iterator[A], itB: Iterator[B])(f: (A, B) => Option[C]): Iterator[C]
     Definition Classes
       Collections
407.  final def mapFrom[A, A1 >: A, B](xs: List[A])(f: (A) => B): Map[A1, B]
     Definition Classes
       Collections
408.  final def mapFromArray[A, B](arr: Array[A])(f: (A) => B): List[B]
     Definition Classes
       Collections
409.  final def mapList[A, B](as: List[A])(f: (A) => B): List[B]

     A version of List#map, specialized for List, and optimized to avoid allocation if `as` is empty

     A version of List#map, specialized for List, and optimized to avoid allocation if `as` is empty

     Definition Classes
       Collections
410.  def mapParamss[T](sym: Symbol)(f: (Symbol) => T): List[List[T]]

     A deep map on a symbol's paramss.

     A deep map on a symbol's paramss.

     Definition Classes
       Symbols
411.  final def mapToArray[A, B](as: List[A], arr: Array[B], i: Int)(f: (A) => B): Unit
     Definition Classes
       Collections
412.  final def mapToArray[A, B](xs: List[A])(f: (A) => B)(implicit arg0: ClassTag[B]): Array[B]
     Definition Classes
       Collections
413.  final def mapWithIndex[A, B](xs: List[A])(f: (A, Int) => B): List[B]
     Definition Classes
       Collections
414.  final def markAllCompleted(sym1: Symbol, sym2: Symbol): Unit
     Definition Classes
       Symbols
415.  final def markAllCompleted(sym: Symbol): Unit
     Definition Classes
       Symbols
416.  final def markFlagsCompleted(sym1: Symbol, sym2: Symbol)(mask: Long): Unit
     Definition Classes
       Symbols
417.  final def markFlagsCompleted(sym: Symbol)(mask: Long): Unit
     Definition Classes
       Symbols
418.  final def matchesType(tp1: Type, tp2: Type, alwaysMatchSimple: Boolean): Boolean

     A function implementing `tp1` matches `tp2`.

     A function implementing `tp1` matches `tp2`.

     Definition Classes
       Types
419.  def matchingParams(syms1: List[Symbol], syms2: List[Symbol]): Boolean

     Are `syms1` and `syms2` parameter lists with pairwise equivalent types?

     Are `syms1` and `syms2` parameter lists with pairwise equivalent types?

     Attributes
       protected[reflect.internal]
     Definition Classes
       Types
420.  final val maxToStringRecursions: Int(50)

     The maximum number of recursions allowed in toString

     The maximum number of recursions allowed in toString

     Definition Classes
       TypeToStrings
421.  def mergePrefixAndArgs(tps0: List[Type], variance: Variance, depth: Depth): Type

     Compute lub (if `variance == Covariant`) or glb (if `variance == Contravariant`) of given list of types `tps`.

     Compute lub (if `variance == Covariant`) or glb (if `variance == Contravariant`) of given list of types `tps`. All types in `tps` are typerefs or singletypes with the same symbol. Return `x` if the computation succeeds with result `x`. Return `NoType` if the computation fails.

     Definition Classes
       Types
422.  final def mexists[A](xss: List[List[A]])(p: (A) => Boolean): Boolean

     All these mm methods are "deep map" style methods for mapping etc.

     All these mm methods are "deep map" style methods for mapping etc. on a list of lists while avoiding unnecessary intermediate structures like those created via flatten.

     Definition Classes
       Collections
423.  final def mfind[A](xss: List[List[A]])(p: (A) => Boolean): Option[A]
     Definition Classes
       Collections
424.  final def mforall[A](xss: List[List[A]])(p: (A) => Boolean): Boolean
     Definition Classes
       Collections
425.  final def mforeach[A](xss: Iterable[Iterable[A]])(f: (A) => Unit): Unit
     Definition Classes
       Collections
426.  final def mforeach[A](xss: List[List[A]])(f: (A) => Unit): Unit

     These are all written in terms of List because we're trying to wring all the performance we can and List is used almost exclusively in the compiler, but people are branching out in their collections so here's an overload.

     These are all written in terms of List because we're trying to wring all the performance we can and List is used almost exclusively in the compiler, but people are branching out in their collections so here's an overload.

     Definition Classes
       Collections
427.  def mirrorThatLoaded(sym: Symbol): Mirror

     Returns the mirror that loaded given symbol

     Returns the mirror that loaded given symbol

     Definition Classes
       JavaMirrors → SymbolTable
428.  val missingAliasException: MissingAliasControl
     Definition Classes
       Types
429.  def missingHook(owner: Symbol, name: Name): Symbol

     1.

     1. If `owner` is a package class (but not the empty package) and `name` is a term name, make a new package <owner>.<name>, otherwise return NoSymbol. Exception: If owner is root and a java class with given name exists, create symbol in empty package instead 2. If `owner` is the scala package and `name` designates a phantom class, return the corresponding class symbol and enter it into this mirror's ScalaPackage.

     Definition Classes
       JavaMirrors → SymbolTable
430.  def mkImporter(from0: Universe): Importer { val from: from0.type }
     Definition Classes
       Importers
431.  final def mkThreadLocalStorage[T](x: => T): ThreadLocalStorage[T]
     Definition Classes
       ThreadLocalStorage
     Annotations
       @inline()
432.  final def mmap[A, B](xss: List[List[A]])(f: (A) => B): collection.immutable.List[collection.immutable.List[B]]
     Definition Classes
       Collections
433.  final val nameDebug: Boolean(false)
     Definition Classes
       Names
434.  final def nameTableSize: Int
     Definition Classes
       Names
435.  final def ne(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
436.  def nestedMemberType(sym: Symbol, pre: Type, owner: Symbol): Type

     A more persistent version of `Type#memberType` which does not require that the symbol is a direct member of the prefix.

     A more persistent version of `Type#memberType` which does not require that the symbol is a direct member of the prefix.

     For instance:

         class C[T] {
           sealed trait F[A]
           object X {
             object S1 extends F[T]
           }
           class S2 extends F[T]
         }
         object O extends C[Int] {
           def foo(f: F[Int]) = f match {...} // need to enumerate sealed subtypes of the scrutinee here.
         }
         class S3 extends O.F[String]

         nestedMemberType(<S1>, <O.type>, <C>) = O.X.S1.type
         nestedMemberType(<S2>, <O.type>, <C>) = O.S2.type
         nestedMemberType(<S3>, <O.type>, <C>) = S3.type

     sym

       The symbol of the subtype

     pre

       The prefix from which the symbol is seen

     Definition Classes
       Types
437.  def newBaseTypeSeq(parents: List[Type], elems: Array[Type]): BaseTypeSeq
     Attributes
       protected
     Definition Classes
       SynchronizedOps → BaseTypeSeqs
438.  def newCodePrinter(writer: PrintWriter, tree: Tree, printRootPkg: Boolean): InternalTreePrinter

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

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

     Definition Classes
       Printers → Printers
439.  def newDefDef(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TermName = sym.name.toTermName, tparams: List[TypeDef] = sym.typeParams map TypeDef.apply, vparamss: List[List[ValDef]] = mapParamss(sym)(ValDef.apply), tpt: Tree = TypeTreeMemberType(sym)): DefDef
     Definition Classes
       Trees
440.  def newDefDefAt(pos: Position)(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TermName = sym.name.toTermName, tparams: List[TypeDef] = sym.typeParams map TypeDef.apply, vparamss: List[List[ValDef]] = mapParamss(sym)(ValDef.apply), tpt: Tree = TypeTreeMemberType(sym)): DefDef
     Definition Classes
       Trees
441.  final def newExistentialType(quantified: List[Symbol], underlying: Type): Type

     A creator for existential types which flattens nested existentials.

     A creator for existential types which flattens nested existentials.

     Definition Classes
       Types
     Annotations
       @tailrec()
442.  def newFreeTermSymbol(name: TermName, value: => Any, flags: Long = 0L, origin: String = null): FreeTermSymbol

     Create a new free term.

     Create a new free term. Its owner is NoSymbol.

     Definition Classes
       SynchronizedSymbols → Symbols
443.  def newFreeTypeSymbol(name: TypeName, flags: Long = 0L, origin: String = null): FreeTypeSymbol

     Create a new free type.

     Create a new free type. Its owner is NoSymbol.

     Definition Classes
       SynchronizedSymbols → Symbols
444.  def newLazyTreeCopier: TreeCopier

     Creates a lazy tree copier.

     Creates a lazy tree copier.

     Definition Classes
       JavaUniverse → Trees
445.  def newMappedBaseTypeSeq(orig: BaseTypeSeq, f: (Type) => Type): MappedBaseTypeSeq with SynchronizedBaseTypeSeq
     Attributes
       protected
     Definition Classes
       SynchronizedOps → BaseTypeSeqs
446.  final def newNestedScope(outer: Scope): Scope

     Create a new scope nested in another one with which it shares its elements

     Create a new scope nested in another one with which it shares its elements

     Definition Classes
       Scopes
447.  def newPackageScope(pkgClass: Symbol): PackageScope
     Definition Classes
       SymbolLoaders
448.  def newRawTreePrinter(writer: PrintWriter): RawTreePrinter

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

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

     Definition Classes
       Printers → Printers
449.  def newScope: Scope with SynchronizedScope

     Create a new scope

     Create a new scope

     Definition Classes
       SynchronizedOps → Scopes
450.  def newScopeWith(elems: Symbol*): Scope

     Create a new scope with given initial elements

     Create a new scope with given initial elements

     Definition Classes
       Scopes
451.  def newStrictTreeCopier: TreeCopier

     Creates a strict tree copier.

     Creates a strict tree copier.

     Definition Classes
       JavaUniverse → Trees
452.  def newStubSymbol(owner: Symbol, name: Name, missingMessage: String): Symbol
     Attributes
       protected
     Definition Classes
       Symbols
453.  final def newTermName(bs: Array[Byte], offset: Int, len: Int): TermName

     Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1].

     Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1].

     Definition Classes
       Names
454.  def newTermName(s: String): TermName

     Create a term name from string.

     Create a term name from string.

     Definition Classes
       Names → Names
     Annotations
       @deprecatedOverriding()
455.  final def newTermName(cs: Array[Char], offset: Int, len0: Int, cachedString: String): TermName

     Create a term name from the characters in cs[offset..offset+len-1].

     Create a term name from the characters in cs[offset..offset+len-1]. TODO - have a mode where name validation is performed at creation time (e.g. if a name has the string "$class" in it, then fail if that string is not at the very end.)

     len0

       the length of the name. Negative lengths result in empty names.

     Definition Classes
       Names
456.  final def newTermName(cs: Array[Char]): TermName
     Definition Classes
       Names
457.  final def newTermName(cs: Array[Char], offset: Int, len: Int): TermName

     Create a term name from the characters in cs[offset..offset+len-1].

     Create a term name from the characters in cs[offset..offset+len-1].

     Definition Classes
       Names
458.  final def newTermNameCached(s: String): TermName
     Definition Classes
       Names
459.  def newTreePrinter(): InternalTreePrinter
     Definition Classes
       Printers
460.  def newTreePrinter(stream: OutputStream): InternalTreePrinter
     Definition Classes
       Printers
461.  def newTreePrinter(writer: PrintWriter): InternalTreePrinter

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

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

     Definition Classes
       Printers → Printers
462.  def newTypeDef(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TypeName = sym.name.toTypeName, tparams: List[TypeDef] = sym.typeParams map TypeDef.apply): TypeDef
     Definition Classes
       Trees
463.  final def newTypeName(bs: Array[Byte], offset: Int, len: Int): TypeName

     Create a type name from the UTF8 encoded bytes in bs[offset..offset+len-1].

     Create a type name from the UTF8 encoded bytes in bs[offset..offset+len-1].

     Definition Classes
       Names
464.  final def newTypeName(cs: Array[Char], offset: Int, len: Int): TypeName

     Create a type name from the characters in cs[offset..offset+len-1].

     Create a type name from the characters in cs[offset..offset+len-1].

     Definition Classes
       Names
465.  def newTypeName(s: String): TypeName

     Create a type name from string.

     Create a type name from string.

     Definition Classes
       Names → Names
     Annotations
       @deprecatedOverriding()
466.  final def newTypeName(cs: Array[Char], offset: Int, len: Int, cachedString: String): TypeName
     Definition Classes
       Names
467.  final def newTypeName(cs: Array[Char]): TypeName
     Definition Classes
       Names
468.  final def newTypeNameCached(s: String): TypeName
     Definition Classes
       Names
469.  def newValDef(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TermName = sym.name.toTermName, tpt: Tree = TypeTreeMemberType(sym)): ValDef
     Definition Classes
       Trees
470.  var nextFrom: Array[InfoTransformer]
     Definition Classes
       SymbolTable
471.  def nextId(): Int
     Attributes
       protected
     Definition Classes
       SynchronizedSymbols → Symbols
472.  def nonTrivialMembers(clazz: Symbol): Scope

     Members of the given class, other than those inherited from Any or AnyRef.

     Members of the given class, other than those inherited from Any or AnyRef.

     Definition Classes
       Types
473.  final def normalizePlus(tp: Type): Type
     Definition Classes
       Types
     Annotations
       @tailrec()
474.  final def notify(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
475.  final def notifyAll(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
476.  def numericLub(ts: List[Type]): Type
     Definition Classes
       GlbLubs
477.  def openPackageModule(pkgClass: Symbol, force: Boolean = false): Unit

     if there's a `package` member object in `pkgClass`, enter its members into it.

     if there's a `package` member object in `pkgClass`, enter its members into it.

     Definition Classes
       SymbolTable
478.  def openPackageModule(container: Symbol, dest: Symbol): Unit
     Definition Classes
       SymbolTable
479.  def overloadedType(pre: Type, alternatives: List[Symbol]): Type

     The canonical creator for OverloadedTypes.

     The canonical creator for OverloadedTypes.

     Definition Classes
       Types
480.  final def packSymbols(hidden: List[Symbol], tp: Type, rawOwner: Symbol = NoSymbol): Type

     Compute an existential type from hidden symbols `hidden` and type `tp`.

     Compute an existential type from hidden symbols `hidden` and type `tp`.

     hidden

       The symbols that will be existentially abstracted

     tp

       The original type

     rawOwner

       The owner for Java raw types.

     Definition Classes
       ExistentialsAndSkolems
481.  def paramString(tp: Type): String
     Definition Classes
       TypeDebugging
482.  final def partitionConserve[A](as: List[A])(p: (A) => Boolean): (List[A], List[A])
     Definition Classes
       Collections
483.  final def partitionInto[A](xs: List[A], pred: (A) => Boolean, ayes: ListBuffer[A], nays: ListBuffer[A]): Unit
     Definition Classes
       Collections
484.  def pendingBaseTypes: HashSet[Type]
     Definition Classes
       SynchronizedTypes → Types
485.  def pendingSubTypes: HashSet[SubTypePair]
     Definition Classes
       SynchronizedTypes → TypeComparers
486.  final def period(rid: RunId, pid: Int): Period
     Definition Classes
       SymbolTable
487.  final def phase: Phase
     Definition Classes
       SymbolTable
488.  final def phaseId(period: Period): Int

     The phase identifier of the given period.

     The phase identifier of the given period.

     Definition Classes
       SymbolTable
489.  final def phaseOf(period: Period): Phase

     The phase associated with given period.

     The phase associated with given period.

     Definition Classes
       SymbolTable
490.  final val phaseWithId: Array[Phase]

     The phase which has given index as identifier.

     The phase which has given index as identifier.

     Definition Classes
       SymbolTable
491.  final def phase_=(p: Phase): Unit
     Definition Classes
       SymbolTable
492.  def picklerPhase: SomePhase
     Definition Classes
       JavaUniverse → SymbolTable
493.  def picklerSubTag(tree: Tree): Int
     Definition Classes
       Translations
494.  final def picklerTag(tpe: Type): Int
     Definition Classes
       Translations
     Annotations
       @tailrec()
495.  def picklerTag(sym: Symbol): Int

     Local symbols only.

     Local symbols only. The assessment of locality depends on convoluted conditions which depends in part on the root symbol being pickled, so it cannot be reproduced here. The pickler tags at stake are EXTMODCLASSref and EXTref. Those tags are never produced here - such symbols must be excluded prior to calling this method.

     Definition Classes
       Translations
496.  final def picklerTag(ref: AnyRef): Int
     Definition Classes
       Translations
497.  final def popPhase(ph: Phase): Unit
     Definition Classes
       SymbolTable
498.  lazy val posAssigner: PosAssigner
     Attributes
       protected[this]
     Definition Classes
       Positions
499.  def postErasure: PostErasure { val global: JavaUniverse.this.type }
     Definition Classes
       Transforms
500.  def propagatePackageBoundary(jflags: JavaAccFlags, syms: Symbol*): Unit
     Definition Classes
       PrivateWithin
501.  def propagatePackageBoundary(m: Member, syms: Symbol*): Unit
     Definition Classes
       PrivateWithin
502.  def propagatePackageBoundary(c: Class[_], syms: Symbol*): Unit
     Definition Classes
       PrivateWithin
503.  final def pushPhase(ph: Phase): Phase
     Definition Classes
       SymbolTable
504.  def quotedName(name: String): String
     Definition Classes
       Printers
505.  def quotedName(name: Name): String
     Definition Classes
       Printers
506.  def quotedName(name: Name, decode: Boolean): String

     Adds backticks if the name is a scala keyword.

     Adds backticks if the name is a scala keyword.

     Definition Classes
       Printers
507.  def rangePos(source: SourceFile, start: Int, point: Int, end: Int): Position
     Definition Classes
       Positions
508.  def rawToExistential: TypeMap

     The raw to existential map converts a raw type to an existential type.

     The raw to existential map converts a raw type to an existential type. It is necessary because we might have read a raw type of a parameterized Java class from a class file. At the time we read the type the corresponding class file might still not be read, so we do not know what the type parameters of the type are. Therefore the conversion of raw types to existential types might not have taken place in ClassFileParser.sigToType (where it is usually done).

     Definition Classes
       TypeMaps
509.  def recursionTable: Map[Symbol, Int]
     Definition Classes
       SynchronizedSymbols → Symbols
510.  def recursionTable_=(value: Map[Symbol, Int]): Unit
     Definition Classes
       SynchronizedSymbols → Symbols
511.  def referenceCapturedVariable(vble: Symbol): Tree

     Mark given identifier as a reference to a captured variable itself suppressing dereferencing with the `elem` field.

     Mark given identifier as a reference to a captured variable itself suppressing dereferencing with the `elem` field.

     Definition Classes
       CapturedVariables
512.  def refinedType(parents: List[Type], owner: Symbol): Type

     The canonical creator for a refined type with an initially empty scope.

     The canonical creator for a refined type with an initially empty scope.

     Definition Classes
       Types
513.  def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type

     the canonical creator for a refined type with a given scope

     the canonical creator for a refined type with a given scope

     Definition Classes
       Types
514.  macro def reify[T](expr: T): Expr[T]

     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
515.  def removeAllAnnotationCheckers(): Unit

     Remove all annotation checkers

     Remove all annotation checkers

     Definition Classes
       AnnotationCheckers
516.  def render(what: Any, mkPrinter: (PrintWriter) => JavaUniverse.TreePrinter, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String

     Attributes
       protected
     Definition Classes
       Printers
517.  def repackExistential(tp: Type): Type

     Repack existential types, otherwise they sometimes get unpacked in the wrong location (type inference comes up with an unexpected skolem)

     Repack existential types, otherwise they sometimes get unpacked in the wrong location (type inference comes up with an unexpected skolem)

     Definition Classes
       Types
518.  def reporter: Reporter
     Definition Classes
       JavaUniverse → Reporting
519.  final def require(requirement: Boolean, message: => Any): Unit
     Definition Classes
       SymbolTable
     Annotations
       @inline()
520.  def rootClassLoader: ClassLoader
     Definition Classes
       JavaMirrors
521.  lazy val rootMirror: Mirror

     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
       JavaMirrors → Mirrors
522.  final def runId(period: Period): RunId

     The run identifier of the given period.

     The run identifier of the given period.

     Definition Classes
       SymbolTable
523.  def runtimeMirror(cl: ClassLoader): Mirror

     Creates a runtime reflection mirror from a JVM classloader.

     Creates a runtime reflection mirror from a JVM classloader.

     For more information about `Mirrors`s, see scala.reflect.api.Mirrors or the Reflection Guide: Mirrors

     Definition Classes
       JavaMirrors → JavaUniverse
524.  final def sameElementsEquals(thiss: List[AnyRef], that: List[AnyRef]): Boolean
     Definition Classes
       Collections
525.  final def sameLength(xs1: List[_], xs2: List[_]): Boolean

     True if two lists have the same length.

     True if two lists have the same length. Since calling length on linear sequences is O(n), it is an inadvisable way to test length equality.

     Definition Classes
       Collections
526.  def sameWeakLubAsLub(tps: List[Type]): Boolean

     Does this set of types have the same weak lub as it does regular lub? This is exposed so lub callers can discover whether the trees they are typing will may require further adaptation.

     Does this set of types have the same weak lub as it does regular lub? This is exposed so lub callers can discover whether the trees they are typing will may require further adaptation. It may return false negatives, but it will not return false positives.

     Definition Classes
       GlbLubs
527.  def saveOriginalOwner(sym: Symbol): Unit
     Attributes
       protected
     Definition Classes
       Symbols
528.  def scopeTransform(owner: Symbol)(op: => Scope): Scope
     Definition Classes
       SymbolLoaders
529.  final def sequenceOpt[A](as: List[Option[A]]): Option[List[A]]
     Definition Classes
       Collections
530.  def setAllInfos(clazz: Symbol, module: Symbol, info: Type): Unit
     Attributes
       protected
     Definition Classes
       SymbolLoaders
531.  def setPackageAccessBoundary(sym: Symbol): Symbol
     Definition Classes
       PrivateWithin
532.  lazy val settings: Settings
     Definition Classes
       JavaUniverse → SymbolTable
533.  val shorthands: Set[String]
     Definition Classes
       Types
534.  def shouldLogAtThisPhase: Boolean
     Definition Classes
       SymbolTable
535.  def show(position: Position): String

     Renders a prettified representation of a position.

     Renders a prettified representation of a position.

     Definition Classes
       Printers → Printers
536.  def show(flags: FlagSet): String

     Renders a prettified representation of a flag set.

     Renders a prettified representation of a flag set.

     Definition Classes
       Printers → Printers
537.  def show(name: Name): String

     Renders a prettified representation of a name.

     Renders a prettified representation of a name.

     Definition Classes
       Printers → Printers
538.  def show(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String

     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
539.  def showCode(tree: Tree, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printPositions: BooleanFlag = None, printRootPkg: Boolean = false): String

     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
540.  def showDecl(sym: Symbol): String

     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 → Printers
541.  def showRaw(position: Position): String

     Renders internal structure of a position.

     Renders internal structure of a position.

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

     Renders internal structure of a flag set.

     Renders internal structure of a flag set.

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

     Renders internal structure of a name.

     Renders internal structure of a name.

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

     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
545.  def singleType(pre: Type, sym: Symbol): Type

     The canonical creator for single-types

     The canonical creator for single-types

     Definition Classes
       Types
546.  def singletonBounds(hi: Type): TypeBounds
     Definition Classes
       Types
547.  def skipPrefixOf(pre: Type, clazz: Symbol): Boolean
     Attributes
       protected[reflect.internal]
     Definition Classes
       TypeMaps
548.  def skolemizationLevel: Int
     Definition Classes
       SynchronizedTypes → Types
549.  def skolemizationLevel_=(value: Int): Unit
     Definition Classes
       SynchronizedTypes → Types
550.  def slowButSafeEnteringPhase[T](ph: Phase)(op: => T): T
     Definition Classes
       SymbolTable
551.  def slowButSafeEnteringPhaseNotLaterThan[T](target: Phase)(op: => T): T
     Definition Classes
       SymbolTable
552.  lazy val sn: SymbolNames
     Definition Classes
       StdNames
553.  def solve(tvars: List[TypeVar], tparams: List[Symbol], getVariance: Extractor[Symbol], upper: Boolean, depth: Depth): Boolean

     Solve constraint collected in types `tvars`.

     Solve constraint collected in types `tvars`.

     tvars

       All type variables to be instantiated.

     tparams

       The type parameters corresponding to `tvars`

     getVariance

       Function to extract variances of type parameters; we need to reverse solution direction for all contravariant variables.

     upper

       When `true` search for max solution else min.

     Definition Classes
       TypeConstraints
554.  def spanningTypes(ts: List[Type]): List[Type]

     A minimal type list which has a given list of types as its base type sequence

     A minimal type list which has a given list of types as its base type sequence

     Definition Classes
       GlbLubs
555.  def specializesSym(preLo: Type, symLo: Symbol, preHi: Type, symHi: Symbol, depth: Depth): Boolean

     Does member `symLo` of `tpLo` have a stronger type than member `symHi` of `tpHi`?

     Does member `symLo` of `tpLo` have a stronger type than member `symHi` of `tpHi`?

     Attributes
       protected[reflect.internal]
     Definition Classes
       Types
556.  def specializesSym(tp: Type, sym: Symbol, depth: Depth): Boolean
     Definition Classes
       Types
557.  final val statistics: Statistics with ReflectStats

     Some statistics (normally disabled) set with -Ystatistics

     Some statistics (normally disabled) set with -Ystatistics

     Definition Classes
       JavaUniverse → SymbolTable
558.  final def stripExistentialsAndTypeVars(ts: List[Type], expandLazyBaseType: Boolean = false): (List[Type], List[Symbol])
     Definition Classes
       Types
559.  def subsametypeRecursions: Int
     Definition Classes
       SynchronizedTypes → TypeComparers
560.  def subsametypeRecursions_=(value: Int): Unit
     Definition Classes
       SynchronizedTypes → TypeComparers
561.  final def sumSize(xss: List[List[_]], acc: Int): Int
     Definition Classes
       Collections
     Annotations
       @tailrec()
562.  def supplementErrorMessage(errorMessage: String): String
     Definition Classes
       Reporting
563.  def supplementTyperState(errorMessage: String): String
     Definition Classes
       Reporting
564.  final def suspendingTypeVars[T](tvs: List[TypeVar])(op: => T): T
     Definition Classes
       Types
     Annotations
       @inline()
565.  def symName(tree: Tree, name: Name): String
     Definition Classes
       Printers
566.  def symbolOf[T](implicit arg0: WeakTypeTag[T]): TypeSymbol
     Definition Classes
       Symbols
567.  def synchronizeNames: Boolean
     Attributes
       protected
     Definition Classes
       SynchronizedOps → Names
568.  final def synchronized[T0](arg0: => T0): T0
     Definition Classes
       AnyRef
569.  lazy val termNames: nme.type
     Definition Classes
       StdNames
570.  def throwableAsString(t: Throwable, maxFrames: Int): String
     Definition Classes
       SymbolTable
571.  def throwableAsString(t: Throwable): String
     Definition Classes
       SymbolTable
572.  def toString(): String
     Definition Classes
       AnyRef → Any
573.  def toStringRecursions: Int
     Definition Classes
       SynchronizedTypes → TypeToStrings
574.  def toStringRecursions_=(value: Int): Unit
     Definition Classes
       SynchronizedTypes → TypeToStrings
575.  def toStringSubjects: HashSet[Type]
     Definition Classes
       SynchronizedTypes → TypeToStrings
576.  final val traceSymbolActivity: Boolean

     Dump each symbol to stdout after shutdown.

     Dump each symbol to stdout after shutdown.

     Definition Classes
       SymbolTable
577.  def transformedType(tpe: Type): Type forSome {val _1: PostErasure { val global: JavaUniverse.this.type }}
     Definition Classes
       Transforms
578.  def transformedType(sym: Symbol): Type forSome {val stabilizer$1: PostErasure { val global: JavaUniverse.this.type }}
     Definition Classes
       Transforms
579.  def transparentShallowTransform(container: Symbol, tp: Type)(f: (Type) => Type): Type
     Definition Classes
       Types
580.  final def transposeSafe[A](ass: List[List[A]]): Option[List[List[A]]]
     Definition Classes
       Collections
581.  final def traverseOpt[A, B](as: List[A])(f: (A) => Option[B]): Option[List[B]]
     Definition Classes
       Collections
582.  lazy val treeBuild: TreeGen
     Definition Classes
       Internals
583.  val treeCopy: TreeCopier

     The standard (lazy) tree copier.

     The standard (lazy) tree copier.

     Definition Classes
       Trees
584.  def treeLine(t: Tree): String
     Attributes
       protected
     Definition Classes
       Trees
585.  def treeStatus(t: Tree, enclosingTree: Tree = null): String
     Attributes
       protected
     Definition Classes
       Trees
586.  def treeSymStatus(t: Tree): String
     Attributes
       protected
     Definition Classes
       Trees
587.  def treeToAnnotation(tree: Tree): Annotation
     Attributes
       protected[scala]
     Definition Classes
       AnnotationInfos → Annotations
588.  def treeToString(tree: Tree): String

     By default trees are printed with `show`

     By default trees are printed with `show`

     Attributes
       protected
     Definition Classes
       Printers
589.  final def typeDepth(tp: Type): Depth

     The maximum depth of type `tp`

     The maximum depth of type `tp`

     Definition Classes
       Types
590.  def typeFun(tps: List[Symbol], body: Type): Type

     A creator for a type functions, assuming the type parameters tps already have the right owner.

     A creator for a type functions, assuming the type parameters tps already have the right owner.

     Definition Classes
       Types
591.  lazy val typeNames: tpnme.type
     Definition Classes
       StdNames
592.  def typeOf[T](implicit ttag: TypeTag[T]): Type

     Shortcut for `implicitly[TypeTag[T]].tpe`

     Shortcut for `implicitly[TypeTag[T]].tpe`

     Definition Classes
       TypeTags
593.  def typeParamsString(tp: Type): String
     Definition Classes
       TypeDebugging
594.  def typeParamsToExistentials(clazz: Symbol): List[Symbol]
     Definition Classes
       Types
595.  def typeParamsToExistentials(clazz: Symbol, tparams: List[Symbol]): List[Symbol]
     Definition Classes
       Types
596.  final def typeRef(pre: Type, sym: Symbol, args: List[Type]): Type

     The canonical creator for typerefs todo: see how we can clean this up a bit

     The canonical creator for typerefs todo: see how we can clean this up a bit

     Definition Classes
       Types
     Annotations
       @tailrec()
597.  def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]

     Shortcut for `implicitly[TypeTag[T]]`

     Shortcut for `implicitly[TypeTag[T]]`

     Definition Classes
       TypeTags
598.  def typeToString(tpe: Type): String
     Attributes
       protected
     Definition Classes
       TypeToStrings
599.  def typeTreeSymbol(tree: TypeTree): Symbol

     Delegate for a TypeTree symbol.

     Delegate for a TypeTree symbol. This operation is unsafe because it may trigger type checking when forcing the type symbol of the underlying type.

     Attributes
       protected
     Definition Classes
       Trees
600.  def typeVarsInType(tp: Type): List[TypeVar]

     A list of the typevars in a type.

     A list of the typevars in a type.

     Definition Classes
       Types
601.  final def uncheckedBounds(tp: Type): Type

     Adds the @uncheckedBound annotation if the given `tp` has type arguments

     Adds the @uncheckedBound annotation if the given `tp` has type arguments

     Definition Classes
       Types
602.  def uncurry: UnCurry { val global: JavaUniverse.this.type }
     Definition Classes
       Transforms
603.  lazy val undetBaseTypeSeq: BaseTypeSeq

     A marker object for a base type sequence that's no yet computed.

     A marker object for a base type sequence that's no yet computed. used to catch inheritance cycles

     Definition Classes
       BaseTypeSeqs
604.  def undoLog: UndoLog
     Definition Classes
       SynchronizedTypes → TypeConstraints
605.  def unique[T <: Type](tp: T): T
     Definition Classes
       SynchronizedTypes → Types
606.  def useOffsetPositions: Boolean
     Definition Classes
       Positions
607.  def validateClassInfo(tp: ClassInfoType): Unit

     Assert that packages have package scopes

     Assert that packages have package scopes

     Definition Classes
       SymbolLoaders
608.  def validatePositions(tree: Tree): Unit
     Definition Classes
       Positions
609.  final def varianceInType(tp: Type, considerUnchecked: Boolean = false)(tparam: Symbol): Variance

     Compute variance of type parameter `tparam` in type `tp`.

     Compute variance of type parameter `tparam` in type `tp`.

     Definition Classes
       Variances
610.  final def varianceInTypes(tps: List[Type])(tparam: Symbol): Variance

     Compute variance of type parameter `tparam` in all types `tps`.

     Compute variance of type parameter `tparam` in all types `tps`.

     Definition Classes
       Variances
611.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
612.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
613.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException]) @native()
614.  def weakLub(tps: List[Type]): Type

     If the arguments are all numeric value types, the numeric lub according to the weak conformance spec.

     If the arguments are all numeric value types, the numeric lub according to the weak conformance spec. If any argument has type annotations, take the lub of the unannotated type and call the analyzerPlugin method annotationsLub so it can be further altered. Otherwise, the regular lub.

     Definition Classes
       GlbLubs
615.  def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type

     Shortcut for `implicitly[WeakTypeTag[T]].tpe`

     Shortcut for `implicitly[WeakTypeTag[T]].tpe`

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

     Shortcut for `implicitly[WeakTypeTag[T]]`

     Shortcut for `implicitly[WeakTypeTag[T]]`

     Definition Classes
       TypeTags
617.  def withTypesExplained[A](op: => A): A

     Execute `op` while printing a trace of the operations on types executed.

     Execute `op` while printing a trace of the operations on types executed.

     Definition Classes
       Types
618.  def wrappingIntoTerm(tree0: Tree)(op: (Tree) => Tree): Tree
     Definition Classes
       Trees
619.  def wrappingPos(trees: List[Tree]): Position

     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 tree's position. If some of 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 → Positions
620.  def wrappingPos(default: Position, trees: List[Tree]): Position

     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 that is either focused or not. If the default point falls outside the calculated range, widen the result to include it.

     Definition Classes
       Positions → Positions
621.  def xprintTree(treePrinter: InternalTreePrinter, tree: Tree): Unit

     Hook for extensions

     Hook for extensions

     Definition Classes
       Printers
622.  def xtransform(transformer: Transformer, tree: Tree): Tree

     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
623.  object Alternative extends internal.SymbolTable.AlternativeExtractor with java.io.Serializable

     The constructor/extractor for `Alternative` instances.

     The constructor/extractor for `Alternative` instances.

     Definition Classes
       Trees → Trees
624.  object Annotated extends internal.SymbolTable.AnnotatedExtractor with java.io.Serializable

     The constructor/extractor for `Annotated` instances.

     The constructor/extractor for `Annotated` instances.

     Definition Classes
       Trees → Trees
625.  object AnnotatedType extends internal.SymbolTable.AnnotatedTypeExtractor with java.io.Serializable

     The constructor/extractor for `AnnotatedType` instances.

     The constructor/extractor for `AnnotatedType` instances.

     Definition Classes
       Types → Types
626.  object Annotation extends internal.SymbolTable.AnnotationExtractor

     The constructor/extractor for `Annotation` instances.

     The constructor/extractor for `Annotation` instances.

     Definition Classes
       AnnotationInfos → Annotations
627.  object AnnotationInfo
     Definition Classes
       AnnotationInfos
628.  object AppliedTypeTree extends internal.SymbolTable.AppliedTypeTreeExtractor with java.io.Serializable

     The constructor/extractor for `AppliedTypeTree` instances.

     The constructor/extractor for `AppliedTypeTree` instances.

     Definition Classes
       Trees → Trees
629.  object Apply extends internal.SymbolTable.ApplyExtractor with java.io.Serializable

     The constructor/extractor for `Apply` instances.

     The constructor/extractor for `Apply` instances.

     Definition Classes
       Trees → Trees
630.  object ApproximateDependentMap extends internal.SymbolTable.TypeMap
     Definition Classes
       TypeMaps
631.  object ArrayTypeRef
     Definition Classes
       Types
632.  object Assign extends internal.SymbolTable.AssignExtractor with java.io.Serializable

     The constructor/extractor for `Assign` instances.

     The constructor/extractor for `Assign` instances.

     Definition Classes
       Trees → Trees
633.  case object AutoApplicationAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Indicates that an application to `()` was inserted by the compiler

     Indicates that an application to `()` was inserted by the compiler

     Definition Classes
       StdAttachments
634.  case object BackquotedIdentifierAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     When present, indicates that the host `Ident` has been created from a backquoted identifier.

     When present, indicates that the host `Ident` has been created from a backquoted identifier.

     Definition Classes
       StdAttachments
635.  object Bind extends internal.SymbolTable.BindExtractor with java.io.Serializable

     The constructor/extractor for `Bind` instances.

     The constructor/extractor for `Bind` instances.

     Definition Classes
       Trees → Trees
636.  object Block extends internal.SymbolTable.BlockExtractor with java.io.Serializable

     The constructor/extractor for `Block` instances.

     The constructor/extractor for `Block` instances.

     Definition Classes
       Trees → Trees
637.  case object BooleanParameterType extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Anonymous parameter of `if (_)` may be inferred as Boolean.

     Anonymous parameter of `if (_)` may be inferred as Boolean.

     Definition Classes
       StdAttachments
638.  object BoundedWildcardType extends internal.SymbolTable.BoundedWildcardTypeExtractor with java.io.Serializable

     The constructor/extractor for `BoundedWildcardType` instances.

     The constructor/extractor for `BoundedWildcardType` instances.

     Definition Classes
       Types → Types
639.  case object CaseApplyInheritAccess extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
640.  object CaseDef extends internal.SymbolTable.CaseDefExtractor with java.io.Serializable

     The constructor/extractor for `CaseDef` instances.

     The constructor/extractor for `CaseDef` instances.

     Definition Classes
       Trees → Trees
641.  object ClassDef extends internal.SymbolTable.ClassDefExtractor with java.io.Serializable

     The constructor/extractor for `ClassDef` instances.

     The constructor/extractor for `ClassDef` instances.

     Definition Classes
       Trees → Trees
642.  object ClassInfoType extends internal.SymbolTable.ClassInfoTypeExtractor with java.io.Serializable

     The constructor/extractor for `ClassInfoType` instances.

     The constructor/extractor for `ClassInfoType` instances.

     Definition Classes
       Types → Types
643.  object CompoundType
     Definition Classes
       Types
644.  object CompoundTypeTree extends internal.SymbolTable.CompoundTypeTreeExtractor with java.io.Serializable

     The constructor/extractor for `CompoundTypeTree` instances.

     The constructor/extractor for `CompoundTypeTree` instances.

     Definition Classes
       Trees → Trees
645.  object ConsoleWriter extends Writer

     A writer that writes to the current Console and is sensitive to replacement of the Console's output stream.

     A writer that writes to the current Console and is sensitive to replacement of the Console's output stream.

     Definition Classes
       Printers
646.  object Constant extends internal.SymbolTable.ConstantExtractor with java.io.Serializable

     The constructor/extractor for `Constant` instances.

     The constructor/extractor for `Constant` instances.

     Definition Classes
       Constants → Constants
647.  object ConstantType extends internal.SymbolTable.ConstantTypeExtractor

     The constructor/extractor for `ConstantType` instances.

     The constructor/extractor for `ConstantType` instances.

     Definition Classes
       Types → Types
648.  case object ConstructorNeedsFence extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
649.  object CyclicReference extends java.io.Serializable
     Definition Classes
       Symbols
650.  object DefDef extends internal.SymbolTable.DefDefExtractor with java.io.Serializable

     The constructor/extractor for `DefDef` instances.

     The constructor/extractor for `DefDef` instances.

     Definition Classes
       Trees → Trees
651.  case object DelambdafyTarget extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
652.  case object DiscardedExpr extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Discarded pure expression observed at refchecks.

     Discarded pure expression observed at refchecks.

     Definition Classes
       StdAttachments
653.  case object DiscardedValue extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Adapted under value discard at typer.

     Adapted under value discard at typer.

     Definition Classes
       StdAttachments
654.  case object DottyEnumSingleton extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
655.  object EmptyScope extends internal.SymbolTable.Scope

     The empty scope (immutable).

     The empty scope (immutable).

     Definition Classes
       Scopes
656.  case object EmptyTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.CannotHaveAttrs with Product with Serializable

     The empty tree

     The empty tree

     Definition Classes
       Trees → Trees
657.  object ErasedValueType extends java.io.Serializable
     Definition Classes
       Types
658.  object ErroneousCollector extends internal.SymbolTable.TypeCollector[Boolean]
     Definition Classes
       TypeMaps
659.  case object ErrorType extends internal.SymbolTable.Type with Product with Serializable

     An object representing an erroneous type

     An object representing an erroneous type

     Definition Classes
       Types
660.  object ExistentialType extends internal.SymbolTable.ExistentialTypeExtractor with java.io.Serializable

     The constructor/extractor for `ExistentialType` instances.

     The constructor/extractor for `ExistentialType` instances.

     Definition Classes
       Types → Types
661.  object ExistentialTypeTree extends internal.SymbolTable.ExistentialTypeTreeExtractor with java.io.Serializable

     The constructor/extractor for `ExistentialTypeTree` instances.

     The constructor/extractor for `ExistentialTypeTree` instances.

     Definition Classes
       Trees → Trees
662.  case object FieldTypeInferred extends internal.SymbolTable.PlainAttachment with Product with Serializable

     For `val i = 42`, marks field as inferred so accessor (getter) can warn if implicit.

     For `val i = 42`, marks field as inferred so accessor (getter) can warn if implicit.

     Definition Classes
       StdAttachments
663.  object Flag extends internal.SymbolTable.FlagValues

     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 → FlagSets
664.  object FoldableConstantType extends java.io.Serializable
     Definition Classes
       Types
665.  case object ForAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Identifies trees are either result or intermediate value of for loop desugaring.

     Identifies trees are either result or intermediate value of for loop desugaring.

     Definition Classes
       StdAttachments
666.  object Function extends internal.SymbolTable.FunctionExtractor with java.io.Serializable

     The constructor/extractor for `Function` instances.

     The constructor/extractor for `Function` instances.

     Definition Classes
       Trees → Trees
667.  object GenPolyType

     A creator and extractor for type parameterizations that strips empty type parameter lists.

     A creator and extractor for type parameterizations that strips empty type parameter lists. Use this factory method to indicate the type has kind * (it's a polymorphic value)

     Definition Classes
       Types
668.  object HasTypeMember
     Definition Classes
       Types
669.  object Ident extends internal.SymbolTable.IdentExtractor with java.io.Serializable

     The constructor/extractor for `Ident` instances.

     The constructor/extractor for `Ident` instances.

     Definition Classes
       Trees → Trees
670.  object If extends internal.SymbolTable.IfExtractor with java.io.Serializable

     The constructor/extractor for `If` instances.

     The constructor/extractor for `If` instances.

     Definition Classes
       Trees → Trees
671.  object Import extends internal.SymbolTable.ImportExtractor with java.io.Serializable

     The constructor/extractor for `Import` instances.

     The constructor/extractor for `Import` instances.

     Definition Classes
       Trees → Trees
672.  object ImportSelector extends internal.SymbolTable.ImportSelectorExtractor with java.io.Serializable

     The constructor/extractor for `ImportSelector` instances.

     The constructor/extractor for `ImportSelector` instances.

     Definition Classes
       Trees → Trees
673.  case object InfixAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Indicates that an application was infix (on Apply tree)

     Indicates that an application was infix (on Apply tree)

     Definition Classes
       StdAttachments
674.  case object InlineCallsiteAttachment extends internal.SymbolTable.InlineAnnotatedAttachment with Product with Serializable
     Definition Classes
       StdAttachments
675.  case object InterpolatedString extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
676.  object IsDependentCollector extends internal.SymbolTable.TypeCollector[Boolean]
     Definition Classes
       TypeMaps
677.  object IsRelatableCollector extends internal.SymbolTable.TypeCollector[Boolean]
     Definition Classes
       TypeMaps
678.  object Kind
     Definition Classes
       Kinds
679.  case object KnownDirectSubclassesCalled extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Attached to a class symbol to indicate that its children have been observed via knownDirectSubclasses.

     Attached to a class symbol to indicate that its children have been observed via knownDirectSubclasses. Children added subsequently will trigger an error to indicate that the earlier observation was incomplete.

     Definition Classes
       StdAttachments
680.  object LabelDef extends internal.SymbolTable.LabelDefExtractor with java.io.Serializable

     The constructor/extractor for `LabelDef` instances.

     The constructor/extractor for `LabelDef` instances.

     Definition Classes
       Trees → Trees
681.  object Literal extends internal.SymbolTable.LiteralExtractor with java.io.Serializable

     The constructor/extractor for `Literal` instances.

     The constructor/extractor for `Literal` instances.

     Definition Classes
       Trees → Trees
682.  object LiteralType extends java.io.Serializable
     Definition Classes
       Types
683.  case object LookupNotFound extends internal.SymbolTable.NameLookup with Product with Serializable
     Definition Classes
       Scopes
684.  object Match extends internal.SymbolTable.MatchExtractor with java.io.Serializable

     The constructor/extractor for `Match` instances.

     The constructor/extractor for `Match` instances.

     Definition Classes
       Trees → Trees
685.  object MethodType extends internal.SymbolTable.MethodTypeExtractor with java.io.Serializable

     The constructor/extractor for `MethodType` instances.

     The constructor/extractor for `MethodType` instances.

     Definition Classes
       Types → Types
686.  object MethodValue
     Definition Classes
       Trees
687.  object Modifiers extends internal.SymbolTable.ModifiersExtractor with java.io.Serializable

     The constructor/extractor for `Modifiers` instances.

     The constructor/extractor for `Modifiers` instances.

     Definition Classes
       Trees → Trees
688.  object ModuleDef extends internal.SymbolTable.ModuleDefExtractor with java.io.Serializable

     The constructor/extractor for `ModuleDef` instances.

     The constructor/extractor for `ModuleDef` instances.

     Definition Classes
       Trees → Trees
689.  case object MultiDefAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Indicates that a definition was part of either a pattern or "sequence shorthand" that introduced multiple definitions.

     Indicates that a definition was part of either a pattern or "sequence shorthand" that introduced multiple definitions. All variables must be either `val` or `var`.

     Definition Classes
       StdAttachments
690.  case object MultiargInfixAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Mark the syntax for linting purposes.

     Mark the syntax for linting purposes.

     Definition Classes
       StdAttachments
691.  object NamedArg extends internal.SymbolTable.NamedArgExtractor with java.io.Serializable

     The constructor/extractor for `NamedArg` instances.

     The constructor/extractor for `NamedArg` instances.

     Definition Classes
       Trees → Trees
692.  object New extends internal.SymbolTable.NewExtractor with java.io.Serializable

     The constructor/extractor for `New` instances.

     The constructor/extractor for `New` instances.

     Definition Classes
       Trees → Trees
693.  case object NoInlineCallsiteAttachment extends internal.SymbolTable.InlineAnnotatedAttachment with Product with Serializable
     Definition Classes
       StdAttachments
694.  case object NoPrefix extends internal.SymbolTable.Type with Product with Serializable

     An object representing a non-existing prefix

     An object representing a non-existing prefix

     Definition Classes
       Types → Types
695.  case object NoType extends internal.SymbolTable.Type with Product with Serializable

     An object representing a non-existing type

     An object representing a non-existing type

     Definition Classes
       Types → Types
696.  case object NoWarnAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     A pattern binding exempt from unused warning.

     A pattern binding exempt from unused warning.

     Its host `Ident` has been created from a pattern2 binding, `case x @ p`. In the absence of named parameters in patterns, allows nuanced warnings for unused variables. Hence, `case X(x = _) =>` would not warn; for now, `case X(x @ _) =>` is documentary if x is unused.

     Definition Classes
       StdAttachments
697.  object NullaryMethodType extends internal.SymbolTable.NullaryMethodTypeExtractor with java.io.Serializable

     The constructor/extractor for `NullaryMethodType` instances.

     The constructor/extractor for `NullaryMethodType` instances.

     Definition Classes
       Types → Types
698.  case object NullaryOverrideAdapted extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
699.  case object OuterArgCanBeElided extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Attached to a local class that has its outer field elided.

     Attached to a local class that has its outer field elided. A `null` constant may be passed in place of the outer parameter, can help callers to avoid capturing the outer instance.

     Definition Classes
       StdAttachments
700.  object PackageDef extends internal.SymbolTable.PackageDefExtractor with java.io.Serializable

     The constructor/extractor for `PackageDef` instances.

     The constructor/extractor for `PackageDef` instances.

     Definition Classes
       Trees → Trees
701.  case object PatVarDefAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Indicates that a `ValDef` was synthesized from a pattern definition, `val P(x)`.

     Indicates that a `ValDef` was synthesized from a pattern definition, `val P(x)`.

     Definition Classes
       StdAttachments
702.  object PolyType extends internal.SymbolTable.PolyTypeExtractor with java.io.Serializable

     The constructor/extractor for `PolyType` instances.

     The constructor/extractor for `PolyType` instances.

     Definition Classes
       Types → Types
703.  case object PostfixAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Indicates that a selection was postfix (on Select tree)

     Indicates that a selection was postfix (on Select tree)

     Definition Classes
       StdAttachments
704.  object ProperTypeKind
     Definition Classes
       Kinds
705.  object RefTree extends internal.SymbolTable.RefTreeExtractor

     The constructor/extractor for `RefTree` instances.

     The constructor/extractor for `RefTree` instances.

     Definition Classes
       Trees → Trees
706.  object ReferenceToBoxed extends internal.SymbolTable.ReferenceToBoxedExtractor with java.io.Serializable
     Definition Classes
       Trees
707.  object RefinedType extends internal.SymbolTable.RefinedTypeExtractor with java.io.Serializable

     The constructor/extractor for `RefinedType` instances.

     The constructor/extractor for `RefinedType` instances.

     Definition Classes
       Types → Types
708.  object Return extends internal.SymbolTable.ReturnExtractor with java.io.Serializable

     The constructor/extractor for `Return` instances.

     The constructor/extractor for `Return` instances.

     Definition Classes
       Trees → Trees
709.  case object RootSelection extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
710.  object Scope
     Definition Classes
       Scopes
711.  object Select extends internal.SymbolTable.SelectExtractor with java.io.Serializable

     The constructor/extractor for `Select` instances.

     The constructor/extractor for `Select` instances.

     Definition Classes
       Trees → Trees
712.  object SelectFromTypeTree extends internal.SymbolTable.SelectFromTypeTreeExtractor with java.io.Serializable

     The constructor/extractor for `SelectFromTypeTree` instances.

     The constructor/extractor for `SelectFromTypeTree` instances.

     Definition Classes
       Trees → Trees
713.  object SingleType extends internal.SymbolTable.SingleTypeExtractor with java.io.Serializable

     The constructor/extractor for `SingleType` instances.

     The constructor/extractor for `SingleType` instances.

     Definition Classes
       Types → Types
714.  object SingletonTypeTree extends internal.SymbolTable.SingletonTypeTreeExtractor with java.io.Serializable

     The constructor/extractor for `SingletonTypeTree` instances.

     The constructor/extractor for `SingletonTypeTree` instances.

     Definition Classes
       Trees → Trees
715.  object Star extends internal.SymbolTable.StarExtractor with java.io.Serializable

     The constructor/extractor for `Star` instances.

     The constructor/extractor for `Star` instances.

     Definition Classes
       Trees → Trees
716.  object StaticallyAnnotatedType
     Definition Classes
       Types
717.  object SubstSymMap
     Definition Classes
       TypeMaps
718.  object Super extends internal.SymbolTable.SuperExtractor with java.io.Serializable

     The constructor/extractor for `Super` instances.

     The constructor/extractor for `Super` instances.

     Definition Classes
       Trees → Trees
719.  object SuperType extends internal.SymbolTable.SuperTypeExtractor with java.io.Serializable

     The constructor/extractor for `SuperType` instances.

     The constructor/extractor for `SuperType` instances.

     Definition Classes
       Types → Types
720.  case object SyntheticUnitAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Identifies unit constants which were inserted by the compiler (e.g.

     Identifies unit constants which were inserted by the compiler (e.g. gen.mkBlock)

     Definition Classes
       StdAttachments
721.  object Template extends internal.SymbolTable.TemplateExtractor with java.io.Serializable

     The constructor/extractor for `Template` instances.

     The constructor/extractor for `Template` instances.

     Definition Classes
       Trees → Trees
722.  object TermName extends internal.Names.TermNameExtractor

     The constructor/extractor for `TermName` instances.

     The constructor/extractor for `TermName` instances.

     Definition Classes
       Names → Names
723.  object This extends internal.SymbolTable.ThisExtractor with java.io.Serializable

     The constructor/extractor for `This` instances.

     The constructor/extractor for `This` instances.

     Definition Classes
       Trees → Trees
724.  object ThisType extends internal.SymbolTable.ThisTypeExtractor with java.io.Serializable

     The constructor/extractor for `ThisType` instances.

     The constructor/extractor for `ThisType` instances.

     Definition Classes
       Types → Types
725.  object Throw extends internal.SymbolTable.ThrowExtractor with java.io.Serializable

     The constructor/extractor for `Throw` instances.

     The constructor/extractor for `Throw` instances.

     Definition Classes
       Trees → Trees
726.  object ThrownException

     Extracts the type of the thrown exception from an AnnotationInfo.

     Extracts the type of the thrown exception from an AnnotationInfo.

     Supports both “old-style” `@throws(classOf[Exception])` as well as “new-style” `@throws[Exception]("cause")` annotations.

     Definition Classes
       AnnotationInfos
727.  object Try extends internal.SymbolTable.TryExtractor with java.io.Serializable

     The constructor/extractor for `Try` instances.

     The constructor/extractor for `Try` instances.

     Definition Classes
       Trees → Trees
728.  object TypeApply extends internal.SymbolTable.TypeApplyExtractor with java.io.Serializable

     The constructor/extractor for `TypeApply` instances.

     The constructor/extractor for `TypeApply` instances.

     Definition Classes
       Trees → Trees
729.  object TypeBounds extends internal.SymbolTable.TypeBoundsExtractor with java.io.Serializable

     The constructor/extractor for `TypeBounds` instances.

     The constructor/extractor for `TypeBounds` instances.

     Definition Classes
       Types → Types
730.  object TypeBoundsTree extends internal.SymbolTable.TypeBoundsTreeExtractor with java.io.Serializable

     The constructor/extractor for `TypeBoundsTree` instances.

     The constructor/extractor for `TypeBoundsTree` instances.

     Definition Classes
       Trees → Trees
731.  object TypeConKind
     Definition Classes
       Kinds
732.  object TypeDef extends internal.SymbolTable.TypeDefExtractor with java.io.Serializable

     The constructor/extractor for `TypeDef` instances.

     The constructor/extractor for `TypeDef` instances.

     Definition Classes
       Trees → Trees
733.  object TypeName extends internal.Names.TypeNameExtractor

     The constructor/extractor for `TypeName` instances.

     The constructor/extractor for `TypeName` instances.

     Definition Classes
       Names → Names
734.  object TypeRef extends internal.SymbolTable.TypeRefExtractor with java.io.Serializable

     The constructor/extractor for `TypeRef` instances.

     The constructor/extractor for `TypeRef` instances.

     Definition Classes
       Types → Types
735.  object TypeTree extends internal.SymbolTable.TypeTreeExtractor with java.io.Serializable

     The constructor/extractor for `TypeTree` instances.

     The constructor/extractor for `TypeTree` instances.

     Definition Classes
       Trees → Trees
736.  object TypeVar extends java.io.Serializable
     Definition Classes
       Types
737.  object Typed extends internal.SymbolTable.TypedExtractor with java.io.Serializable

     The constructor/extractor for `Typed` instances.

     The constructor/extractor for `Typed` instances.

     Definition Classes
       Trees → Trees
738.  case object TypedExpectingUnitAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Marks a Typed tree with Unit tpt.

     Marks a Typed tree with Unit tpt.

     Definition Classes
       StdAttachments
739.  object UnApply extends internal.SymbolTable.UnApplyExtractor with java.io.Serializable

     The constructor/extractor for `UnApply` instances.

     The constructor/extractor for `UnApply` instances.

     Definition Classes
       Trees → Trees
740.  case object UnmappableAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable
     Definition Classes
       AnnotationInfos
741.  object UnmappableAnnotation extends internal.SymbolTable.CompleteAnnotationInfo
     Definition Classes
       AnnotationInfos
742.  case object UnmappableTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with Product with Serializable
     Definition Classes
       Types
743.  case object UnnamedArg extends internal.SymbolTable.PlainAttachment with Product with Serializable

     Not a named arg in an application.

     Not a named arg in an application. Used for suspicious literal booleans.

     Definition Classes
       StdAttachments
744.  object UnrelatableCollector extends internal.SymbolTable.CollectTypeCollector[internal.SymbolTable.TypeSkolem]
     Definition Classes
       TypeMaps
745.  case object UseInvokeSpecial extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
746.  object ValDef extends internal.SymbolTable.ValDefExtractor with java.io.Serializable

     The constructor/extractor for `ValDef` instances.

     The constructor/extractor for `ValDef` instances.

     Definition Classes
       Trees → Trees
747.  object ValOrDefDef
     Definition Classes
       Trees
748.  case object VirtualStringContext extends internal.SymbolTable.PlainAttachment with Product with Serializable
     Definition Classes
       StdAttachments
749.  case object WildcardType extends internal.SymbolTable.ProtoType with Product with Serializable

     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 → Types
750.  object abstractTypesToBounds extends internal.SymbolTable.TypeMap

     Type with all top-level occurrences of abstract types replaced by their bounds

     Type with all top-level occurrences of abstract types replaced by their bounds

     Definition Classes
       TypeMaps
751.  object adaptToNewRunMap extends internal.SymbolTable.TypeMap
     Definition Classes
       TypeMaps
752.  object binarynme

     Java binary names, like scala/runtime/Nothing$.

     Java binary names, like scala/runtime/Nothing$.

     Definition Classes
       StdNames
753.  object definitions extends internal.SymbolTable.DefinitionsClass

     A value containing all standard definitions in DefinitionsApi

     A value containing all standard definitions in DefinitionsApi

     Definition Classes
       Definitions → StandardDefinitions
754.  object dropIllegalStarTypes extends internal.SymbolTable.TypeMap

     Turn any T* types into Seq[T] except when in method parameter position.

     Turn any T* types into Seq[T] except when in method parameter position.

     Definition Classes
       TypeMaps
755.  object dropSingletonType extends internal.SymbolTable.TypeMap

     Remove any occurrence of type <singleton> from this type and its parents

     Remove any occurrence of type <singleton> from this type and its parents

     Definition Classes
       TypeMaps
756.  object duplicateAndResetPos extends internal.SymbolTable.Transformer
     Definition Classes
       Trees
757.  object fulltpnme extends internal.SymbolTable.TypeNames

     For fully qualified type names.

     For fully qualified type names.

     Definition Classes
       StdNames
758.  object identityTypeMap extends internal.SymbolTable.TypeMap

     A map that is conceptually an identity, but in practice may perform some side effects.

     A map that is conceptually an identity, but in practice may perform some side effects.

     Definition Classes
       TypeMaps
759.  object inferKind

     Starting from a Symbol (sym) or a Type (tpe), infer the kind that classifies it (sym.tpeHK/tpe).

     Starting from a Symbol (sym) or a Type (tpe), infer the kind that classifies it (sym.tpeHK/tpe).

     Definition Classes
       Kinds
760.  object nme extends internal.SymbolTable.TermNames
     Definition Classes
       StdNames
761.  object noPrint extends (internal.SymbolTable.Tree) => Boolean

     There's a whole lot of implementation detail which is nothing but noise when you are trying to see what's going on.

     There's a whole lot of implementation detail which is nothing but noise when you are trying to see what's going on. This is my attempt to filter it out.

     Definition Classes
       TypeDebugging
762.  object noSelfType extends internal.SymbolTable.ValDef with internal.SymbolTable.CannotHaveAttrs

     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 → Trees
763.  object normalizeAliases extends internal.SymbolTable.TypeMap

     Normalize any type aliases within this type (@see Type#normalize).

     Normalize any type aliases within this type (@see Type#normalize). Note that this depends very much on the call to "normalize", not "dealias", so it is no longer carries the too-stealthy name "deAlias".

     Definition Classes
       TypeMaps
764.  object pendingSuperCall extends internal.SymbolTable.Apply with internal.SymbolTable.CannotHaveAttrs

     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 → Trees
765.  object perRunCaches
     Definition Classes
       SymbolTable
766.  object tpnme extends internal.SymbolTable.TypeNames
     Definition Classes
       StdNames
767.  object traceSymbols extends TraceSymbolActivity
     Definition Classes
       SymbolTable
768.  object treeInfo extends TreeInfo
     Definition Classes
       JavaUniverse → SymbolTable
769.  object typeDebug extends AnsiColor

     Light color wrappers.

     Light color wrappers.

     Definition Classes
       TypeDebugging
770.  object typeVarToOriginMap extends internal.SymbolTable.TypeMap

     A map to convert each occurrence of a type variable to its origin.

     A map to convert each occurrence of a type variable to its origin.

     Definition Classes
       TypeMaps
771.  object unwrapToClass extends internal.SymbolTable.ClassUnwrapper
     Definition Classes
       Types
772.  object unwrapToStableClass extends internal.SymbolTable.ClassUnwrapper
     Definition Classes
       Types
773.  object unwrapWrapperTypes extends internal.SymbolTable.TypeUnwrapper
     Definition Classes
       Types
774.  object wildcardExtrapolation extends internal.SymbolTable.VariancedTypeMap

     Get rid of BoundedWildcardType where variance allows us to do so.

     Get rid of BoundedWildcardType where variance allows us to do so. Invariant: `wildcardExtrapolation(tp) =:= tp`

     For example, the MethodType given by `def bla(x: (_ >: String)): (_ <: Int)` is both a subtype and a supertype of `def bla(x: String): Int`.

     Definition Classes
       TypeMaps

### Deprecated Value Members

1.  final def assert(assertion: Boolean): Unit
   Definition Classes
     SymbolTable
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.5) consider supplying an explanatory message

2.  final def atPhase[T](ph: Phase)(op: => T): T
   Definition Classes
     SymbolTable
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.10.0) use enteringPhase

3.  def chrs: Array[Char]
   Definition Classes
     Names
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.9) Don't access name table contents directly.

4.  def chrs_=(cs: Array[Char]): Unit
   Definition Classes
     Names
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.9) Don't access name table contents directly.

5.  lazy val compat: Compat

   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 → Internals
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

6.  lazy val emptyValDef: noSelfType.type
   Definition Classes
     Trees → Trees
   Annotations
     @deprecated
   Deprecated

     (Since version 2.11.0) use `noSelfType` instead

7.  def formatted(fmtstr: String): String
   Implicit
     This member is added by an implicit conversion from JavaUniverse toStringFormat[JavaUniverse] performed by method StringFormat in scala.Predef.
   Definition Classes
     StringFormat
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.12.16) Use `formatString.format(value)` instead of `value.formatted(formatString)`, or use the `f""` string interpolator. In Java 15 and later, `formatted` resolves to the new method in String which has reversed parameters.

8.  def freshExistentialName(suffix: String): TypeName
   Attributes
     protected
   Definition Classes
     Symbols
   Annotations
     @deprecated
   Deprecated

     (Since version 2.12.1) Use overload that accepts an id

9.  def isRaw(sym: Symbol, args: List[Type]): Boolean
   Definition Classes
     Types
   Annotations
     @deprecated
   Deprecated

     (Since version 2.10.1) use isRawType

10.  def itransform(transformer: Transformer, tree: Tree): Tree

    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 → Trees
    Annotations
      @deprecated
    Deprecated

      (Since version 2.12.3) Use Tree#transform instead

11.  def itraverse(traverser: Traverser, tree: Tree): Unit

    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 → Trees
    Annotations
      @deprecated
    Deprecated

      (Since version 2.12.3) Use Tree#traverse instead

12.  final def newAsSeenFromMap(pre: Type, clazz: Symbol): AsSeenFromMap
    Definition Classes
      TypeMaps
    Annotations
      @deprecated
    Deprecated

      (Since version 2.12.0) use new AsSeenFromMap instead

13.  def nextExistentialId(): Int
    Attributes
      protected
    Definition Classes
      SynchronizedSymbols → Symbols
    Annotations
      @deprecated
    Deprecated

      (Since version 2.12.1) Global existential IDs no longer used

14.  def polyType(params: List[Symbol], tpe: Type): Type
    Definition Classes
      Types
    Annotations
      @deprecated
    Deprecated

      (Since version 2.10.0) use genPolyType(...) instead

15.  final def require(requirement: Boolean): Unit
    Definition Classes
      SymbolTable
    Annotations
      @deprecated
    Deprecated

      (Since version 2.12.5) consider supplying an explanatory message

16.  def stringToTermName(s: String): TermName

    A former implicit conversion from String to TermName.

    A former implicit conversion from String to TermName.

    This used to be an implicit conversion, enabling an alternative notation `"map": TermName` as opposed to `TermName("map")`. It is only kept for binary compatibility reasons, and should not be used anymore.

    Definition Classes
      Names
    Annotations
      @deprecated
    Deprecated

      (Since version 2.11.0) use `TermName(s)` instead

17.  def stringToTypeName(s: String): TypeName

    A former implicit conversion from String to TypeName.

    A former implicit conversion from String to TypeName.

    This used to be an implicit conversion, enabling an alternative notation `"List": TypeName` as opposed to `TypeName("List")`. It is only kept for binary compatibility reasons, and should not be used anymore.

    Definition Classes
      Names
    Annotations
      @deprecated
    Deprecated

      (Since version 2.11.0) use `TypeName(s)` instead

18.  def warning(pos: Position, msg: String): Unit
    Definition Classes
      Reporting
    Annotations
      @deprecatedOverriding() @deprecated
    Deprecated

      (Since version 2.13.4) Use `runReporting.warning` instead

19.  def warning(msg: String): Unit
    Definition Classes
      Reporting
    Annotations
      @deprecatedOverriding() @deprecated
    Deprecated

      (Since version 2.13.4) Use `runReporting.warning` instead

20.  def xtraverse(traverser: Traverser, tree: Tree): Unit

    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
    Annotations
      @deprecated
    Deprecated

      (Since version 2.12.3) Use Tree#traverse instead

21.  def →[B](y: B): (JavaUniverse, B)
    Implicit
      This member is added by an implicit conversion from JavaUniverse toArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
      ArrowAssoc
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use `->` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

### Inherited from SymbolTable

### Inherited from runtime.ThreadLocalStorage

### Inherited from Gil

### Inherited from SynchronizedOps

### Inherited from SynchronizedTypes

### Inherited from SynchronizedSymbols

### Inherited from SymbolLoaders

### Inherited from JavaMirrors

### Inherited from TwoWayCaches

### Inherited from api.JavaUniverse

### Inherited from ReflectSetup

### Inherited from JavaUniverseForce

### Inherited from internal.SymbolTable

### Inherited from Reporting

### Inherited from Internals

### Inherited from FreshNames

### Inherited from Translations

### Inherited from PrivateWithin

### Inherited from ReificationSupport

### Inherited from StdCreators

### Inherited from StdAttachments

### Inherited from CapturedVariables

### Inherited from Importers

### Inherited from TypeDebugging

### Inherited from Positions

### Inherited from Printers

### Inherited from Trees

### Inherited from AnnotationCheckers

### Inherited from AnnotationInfos

### Inherited from StdNames

### Inherited from Transforms

### Inherited from InfoTransformers

### Inherited from BaseTypeSeqs

### Inherited from Constants

### Inherited from Definitions

### Inherited from Mirrors

### Inherited from Scopes

### Inherited from FlagSets

### Inherited from ExistentialsAndSkolems

### Inherited from Kinds

### Inherited from Variances

### Inherited from Types

### Inherited from internal.tpe.FindMembers

### Inherited from TypeConstraints

### Inherited from TypeMaps

### Inherited from GlbLubs

### Inherited from CommonOwners

### Inherited from TypeToStrings

### Inherited from TypeComparers

### Inherited from Symbols

### Inherited from Names

### Inherited from Collections

### Inherited from Universe

### Inherited from 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 Names

### Inherited from Scopes

### Inherited from FlagSets

### Inherited from Types

### Inherited from Symbols

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd fromJavaUniverse to any2stringadd[JavaUniverse]

### Inherited by implicit conversion StringFormat fromJavaUniverse to StringFormat[JavaUniverse]

### Inherited by implicit conversion Ensuring fromJavaUniverse to Ensuring[JavaUniverse]

### Inherited by implicit conversion ArrowAssoc fromJavaUniverse to ArrowAssoc[JavaUniverse]

### Macro Specific Additions

### Universe

### API

### Annotations

### Definitions

### Expressions

### Extractors

### Flags

### Internal

### JavaMirrors

### Mirrors

### Names

### Positions

### Printers

### Scopes

### Symbols

### Trees

### Types - Operations

### TypeTags

### Types

### Tree Copying

### Factories

### Tree Traversal and Transformation

### Ungrouped