scala.reflect.runtime

JavaUniverse

class JavaUniverse extends internal.SymbolTable 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, SynchronizedOps, SynchronizedTypes, SynchronizedSymbols, SymbolLoaders, JavaMirrors, api.JavaUniverse, api.JavaMirrors, ReflectSetup, internal.SymbolTable, BuildUtils, StdCreators, StdAttachments, CapturedVariables, Required, Importers, TypeDebugging, Positions, Printers, Trees, AnnotationCheckers, AnnotationInfos, StdNames, Transforms, InfoTransformers, BaseTypeSeqs, Constants, Definitions, Mirrors, Scopes, FlagSets, ExistentialsAndSkolems, Kinds, Types, Symbols, Names, LowPriorityNames, Collections, Universe, Universe, Importers, Printers, Mirrors, BuildUtils, StandardNames, StandardDefinitions, TagInterop, TypeTags, Exprs, Positions, Annotations, Constants, Trees, Names, Scopes, FlagSets, Types, Symbols, AnyRef, Any
Type Hierarchy Learn more about scaladoc diagrams
Content Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Grouped
  2. Alphabetic
  3. By inheritance
Inherited
  1. JavaUniverse
  2. SymbolTable
  3. SynchronizedOps
  4. SynchronizedTypes
  5. SynchronizedSymbols
  6. SymbolLoaders
  7. JavaMirrors
  8. JavaUniverse
  9. JavaMirrors
  10. ReflectSetup
  11. SymbolTable
  12. BuildUtils
  13. StdCreators
  14. StdAttachments
  15. CapturedVariables
  16. Required
  17. Importers
  18. TypeDebugging
  19. Positions
  20. Printers
  21. Trees
  22. AnnotationCheckers
  23. AnnotationInfos
  24. StdNames
  25. Transforms
  26. InfoTransformers
  27. BaseTypeSeqs
  28. Constants
  29. Definitions
  30. Mirrors
  31. Scopes
  32. FlagSets
  33. ExistentialsAndSkolems
  34. Kinds
  35. Types
  36. Symbols
  37. Names
  38. LowPriorityNames
  39. Collections
  40. Universe
  41. Universe
  42. Importers
  43. Printers
  44. Mirrors
  45. BuildUtils
  46. StandardNames
  47. StandardDefinitions
  48. TagInterop
  49. TypeTags
  50. Exprs
  51. Positions
  52. Annotations
  53. Constants
  54. Trees
  55. Names
  56. Scopes
  57. FlagSets
  58. Types
  59. Symbols
  60. AnyRef
  61. Any
Implicitly
  1. by any2stringadd
  2. by any2stringfmt
  3. by any2ArrowAssoc
  4. by any2Ensuring
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new JavaUniverse()

Type Members

  1. trait AbstractTypeRef extends internal.SymbolTable.TypeRef with internal.SymbolTable.NonClassTypeRef

    Definition Classes
    Types
  2. class AbstractTypeSymbol extends internal.SymbolTable.TypeSymbol

    Definition Classes
    Symbols
  3. trait AliasTypeRef extends internal.SymbolTable.TypeRef with internal.SymbolTable.NonClassTypeRef

    Definition Classes
    Types
  4. class AliasTypeSymbol extends internal.SymbolTable.TypeSymbol

    Definition Classes
    Symbols
  5. case class Alternative extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AlternativeApi with Product with Serializable

    Alternatives of patterns.

    Alternatives of patterns.

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

    Definition Classes
    Trees → Trees
  6. trait AlternativeApi extends Universe.TermTreeApi

    The API that all alternatives support

  7. abstract class AlternativeExtractor extends AnyRef

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

  8. trait Annotatable[Self] extends AnyRef

    Definition Classes
    AnnotationInfos
  9. case class Annotated extends internal.SymbolTable.Tree with internal.SymbolTable.AnnotatedApi with Product with Serializable

    A tree that has an annotation attached to it.

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

    Definition Classes
    Trees → Trees
  10. trait AnnotatedApi extends Universe.TreeApi

    The API that all annotateds support

  11. abstract class AnnotatedExtractor extends AnyRef

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

  12. 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 → Types
  13. trait AnnotatedTypeApi extends Universe.TypeApi

    The API that all annotated types support.

  14. abstract class AnnotatedTypeExtractor extends AnyRef

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

  15. trait AnnotationApi extends AnyRef

    The API of Annotation instances.

  16. 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
  17. abstract class AnnotationExtractor extends AnyRef

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

  18. trait AnnotationFilter extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  19. 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
  20. 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
  21. case class AppliedTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.AppliedTypeTreeApi with Product with Serializable

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

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

    Definition Classes
    Trees → Trees
  22. trait AppliedTypeTreeApi extends Universe.TypTreeApi

    The API that all applied type trees support

  23. abstract class AppliedTypeTreeExtractor extends AnyRef

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

  24. class AppliedTypeVar extends internal.SymbolTable.TypeVar

    Precondition: zipped params/args nonEmpty.

    Precondition: zipped params/args nonEmpty. (Size equivalence enforced structurally.)

    Definition Classes
    Types
  25. case class Apply extends internal.SymbolTable.GenericApply with internal.SymbolTable.ApplyApi with Product with Serializable

    Value application

    Value application

    Definition Classes
    Trees → Trees
  26. trait ApplyApi extends Universe.GenericApplyApi

    The API that all applies support

  27. case class ApplyDynamic extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with Product with Serializable

    Definition Classes
    Trees
  28. abstract class ApplyExtractor extends AnyRef

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

  29. class ApplyImplicitView extends internal.SymbolTable.Apply

    Definition Classes
    Trees
  30. class ApplyToImplicitArgs extends internal.SymbolTable.Apply

    Definition Classes
    Trees
  31. class ArgsTypeRef extends internal.SymbolTable.TypeRef

    Definition Classes
    Types
  32. case class ArrayAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with internal.SymbolTable.ArrayArgumentApi with Product with Serializable

    Represents an array of classfile annotation arguments

    Represents an array of classfile annotation arguments

    Definition Classes
    AnnotationInfos
  33. trait ArrayArgumentApi extends AnyRef

    API of ArrayArgument instances.

  34. abstract class ArrayArgumentExtractor extends AnyRef

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

  35. 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
  36. 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
    Types
  37. case class Assign extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AssignApi with Product with Serializable

    Assignment

    Assignment

    Definition Classes
    Trees → Trees
  38. trait AssignApi extends Universe.TermTreeApi

    The API that all assigns support

  39. abstract class AssignExtractor extends AnyRef

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

  40. case class AssignOrNamedArg extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AssignOrNamedArgApi with Product with Serializable

    Either an assignment or a named argument.

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

    Definition Classes
    Trees → Trees
  41. trait AssignOrNamedArgApi extends Universe.TermTreeApi

    The API that all assigns support

  42. abstract class AssignOrNamedArgExtractor extends AnyRef

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

  43. 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
  44. trait AttachableApi extends AnyRef

    The API of reflection artifacts that support scala.reflect.macros.Attachments.

  45. 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
  46. case class Bind extends internal.SymbolTable.DefTree with internal.SymbolTable.BindApi with Product with Serializable

    Bind a variable to a rhs pattern.

    Bind a variable to a rhs pattern.

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

    Definition Classes
    Trees → Trees
  47. trait BindApi extends Universe.DefTreeApi

    The API that all binds support

  48. abstract class BindExtractor extends AnyRef

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

  49. case class Block extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.BlockApi with Product with Serializable

    Block of expressions (semicolon separated expressions)

    Block of expressions (semicolon separated expressions)

    Definition Classes
    Trees → Trees
  50. trait BlockApi extends Universe.TermTreeApi

    The API that all blocks support

  51. abstract class BlockExtractor extends AnyRef

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

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

  53. case class BoundedWildcardType extends internal.SymbolTable.Type 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 → Types
  54. trait BoundedWildcardTypeApi extends Universe.TypeApi

    The API that all this types support.

  55. abstract class BoundedWildcardTypeExtractor extends AnyRef

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

  56. abstract class BuildApi extends AnyRef

    Definition Classes
    BuildUtils
  57. class BuildImpl extends internal.SymbolTable.BuildApi

    Definition Classes
    BuildUtils
  58. case class CaseDef extends internal.SymbolTable.Tree with internal.SymbolTable.CaseDefApi with Product with Serializable

    Case clause in a pattern match.

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

    Definition Classes
    Trees → Trees
  59. trait CaseDefApi extends Universe.TreeApi

    The API that all case defs support

  60. abstract class CaseDefExtractor extends AnyRef

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

  61. class ChangeOwnerTraverser extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  62. case class ClassDef extends internal.SymbolTable.ImplDef with internal.SymbolTable.ClassDefApi with Product with Serializable

    A class definition.

    A class definition.

    Definition Classes
    Trees → Trees
  63. trait ClassDefApi extends Universe.ImplDefApi

    The API that all class defs support

  64. abstract class ClassDefExtractor extends AnyRef

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

  65. 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 → Types
  66. trait ClassInfoTypeApi extends Universe.TypeApi

    The API that all class info types support.

  67. 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.

  68. trait ClassMirror extends Universe.TemplateMirror

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

  69. class ClassSymbol extends internal.SymbolTable.TypeSymbol with internal.SymbolTable.ClassSymbolApi

    A class for class symbols

    A class for class symbols

    Definition Classes
    Symbols → Symbols
  70. trait ClassSymbolApi extends Universe.TypeSymbolApi

    The API of class symbols.

  71. trait ClassTypeRef extends internal.SymbolTable.TypeRef

    Definition Classes
    Types
  72. class ClassUnwrapper extends internal.SymbolTable.TypeUnwrapper

    Definition Classes
    Types
  73. abstract class ClassfileAnnotArg extends Product

    Arguments to classfile annotations (which are written to bytecode as java annotations) are either:

    Arguments to classfile annotations (which are written to bytecode as java annotations) are either:

    • constants
    • arrays of constants
    • or nested classfile annotations
    Definition Classes
    AnnotationInfos
  74. class CollectTreeTraverser[T] extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  75. 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
    Types
  76. abstract class CommonNames extends internal.SymbolTable.NamesApi

    Definition Classes
    StdNames
  77. class CommonOwnerMap extends internal.SymbolTable.TypeTraverserWithResult[internal.SymbolTable.Symbol]

    Attributes
    protected
    Definition Classes
    Types
  78. abstract type CompilationUnit <: CompilationUnitContextApi

    The type of compilation units.

  79. trait CompilationUnitContextApi extends AnyRef

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

  80. class CompleteAnnotationInfo extends internal.SymbolTable.AnnotationInfo

    Definition Classes
    AnnotationInfos
  81. abstract class CompoundType extends internal.SymbolTable.Type

    A common base class for intersection types and class types

    A common base class for intersection types and class types

    Definition Classes
    Types → Types
  82. case class CompoundTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.CompoundTypeTreeApi with Product with Serializable

    Intersection type <parent1> with .

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

    Definition Classes
    Trees → Trees
  83. trait CompoundTypeTreeApi extends Universe.TypTreeApi

    The API that all compound type trees support

  84. abstract class CompoundTypeTreeExtractor extends AnyRef

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

  85. 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
  86. case class Constant extends internal.SymbolTable.ConstantApi with Product with Serializable

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

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

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

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

    assert(Constant(true).value == true)
    Constant(true) match {
      case Constant(s: String) =>  println("A string: " + s)
      case Constant(b: Boolean) => println("A boolean value: " + b)
      case Constant(x) =>          println("Something else: " + x)
    }

    Constant instances can wrap certain kinds of these expressions:

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

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

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

    Usage example:

    enum JavaSimpleEnumeration { FOO, BAR }
    
    import java.lang.annotation.*;
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    public @interface JavaSimpleAnnotation {
      Class<?> classRef();
      JavaSimpleEnumeration enumRef();
    }
    
    @JavaSimpleAnnotation(
      classRef = JavaAnnottee.class,
      enumRef = JavaSimpleEnumeration.BAR
    )
    public class JavaAnnottee {}
    import scala.reflect.runtime.universe._
    import scala.reflect.runtime.{currentMirror => cm}
    
    object Test extends App {
      val jann = typeOf[JavaAnnottee].typeSymbol.annotations(0).javaArgs
      def jarg(name: String) = jann(newTermName(name)) match {
        // Constant is always wrapped into a Literal or LiteralArgument tree node
        case LiteralArgument(ct: Constant) => value
        case _ => sys.error("Not a constant")
      }
    
      val classRef = jarg("classRef").value.asInstanceOf[Type]
                                             // ideally one should match instead of casting
      println(showRaw(classRef))             // TypeRef(ThisType(), JavaAnnottee, List())
      println(cm.runtimeClass(classRef))     // class JavaAnnottee
    
      val enumRef = jarg("enumRef").value.asInstanceOf[Symbol]
                                             // ideally one should match instead of casting
      println(enumRef)                       // value BAR
    
      val siblings = enumRef.owner.typeSignature.declarations
      val enumValues = siblings.filter(sym => sym.isVal && sym.isPublic)
      println(enumValues)                    // Scope{
                                             //   final val FOO: JavaSimpleEnumeration;
                                             //   final val BAR: JavaSimpleEnumeration
                                             // }
    
      // doesn't work because of https://issues.scala-lang.org/browse/SI-6459
      // val enumValue = mirror.reflectField(enumRef.asTerm).get
      val enumClass = cm.runtimeClass(enumRef.owner.asClass)
      val enumValue = enumClass.getDeclaredField(enumRef.name.toString).get(null)
      println(enumValue)                     // BAR
    }
    Definition Classes
    Constants → Constants
  87. abstract class ConstantApi extends AnyRef

    The API of Constant instances.

  88. 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.

  89. abstract case class ConstantType extends internal.SymbolTable.SingletonType with internal.SymbolTable.ConstantTypeApi with Product with Serializable

    A class representing a constant type.

    A class representing a constant type.

    Definition Classes
    Types → Types
  90. trait ConstantTypeApi extends Universe.TypeApi

    The API that all constant types support.

  91. 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.

  92. class ContainsCollector extends internal.SymbolTable.TypeCollector[Boolean]

    A map to implement the contains method.

    A map to implement the contains method.

    Definition Classes
    Types
  93. class ContainsTypeCollector extends internal.SymbolTable.TypeCollector[Boolean]

    A map to implement the contains method.

    A map to implement the contains method.

    Definition Classes
    Types
  94. 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
  95. case class DeBruijnBinder extends internal.SymbolTable.Type with Product with Serializable

    A binder defining data associated with De Bruijn indices.

    A binder defining data associated with De Bruijn indices. Only used as a serialization format.

    Definition Classes
    Types
  96. case class DeBruijnIndex extends internal.SymbolTable.Type with Product with Serializable

    A De Bruijn index referring to a previous type argument.

    A De Bruijn index referring to a previous type argument. Only used as a serialization format.

    Definition Classes
    Types
  97. case class DefDef extends internal.SymbolTable.ValOrDefDef with internal.SymbolTable.DefDefApi with Product with Serializable

    A method or macro definition.

    A method or macro definition.

    Definition Classes
    Trees → Trees
  98. trait DefDefApi extends Universe.ValOrDefDefApi

    The API that all def defs support

  99. abstract class DefDefExtractor extends AnyRef

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

  100. abstract class DefTree extends internal.SymbolTable.SymTree with internal.SymbolTable.NameTree with internal.SymbolTable.DefTreeApi

    A tree which defines a symbol-carrying entity.

    A tree which defines a symbol-carrying entity.

    Definition Classes
    Trees → Trees
  101. trait DefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

    The API that all def trees support

  102. class DefaultPosAssigner extends internal.SymbolTable.Traverser with internal.SymbolTable.PosAssigner

    Attributes
    protected
    Definition Classes
    Positions
  103. trait DefinitionsApi extends Universe.StandardTypes

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

  104. abstract class DefinitionsClass extends internal.SymbolTable.DefinitionsApi with internal.SymbolTable.ValueClassDefinitions

    Definition Classes
    Definitions
  105. 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.

    Definition Classes
    Types
  106. class ErrorScope extends internal.SymbolTable.Scope

    The error scope.

    The error scope.

    Definition Classes
    Scopes
  107. class ExistentialExtrapolation extends internal.SymbolTable.TypeMap with internal.SymbolTable.VariantTypeMap

    Used by existentialAbstraction.

    Used by existentialAbstraction.

    Definition Classes
    Types
  108. case class ExistentialType extends internal.SymbolTable.Type with internal.SymbolTable.RewrappingTypeProxy with internal.SymbolTable.ExistentialTypeApi with Product with Serializable

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

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

    Definition Classes
    Types → Types
  109. trait ExistentialTypeApi extends Universe.TypeApi

    The API that all existential types support.

  110. abstract class ExistentialTypeExtractor extends AnyRef

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

  111. case class ExistentialTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.ExistentialTypeTreeApi with Product with Serializable

    Existential type tree node

    Existential type tree node

    Definition Classes
    Trees → Trees
  112. trait ExistentialTypeTreeApi extends Universe.TypTreeApi

    The API that all existential type trees support

  113. abstract class ExistentialTypeTreeExtractor extends AnyRef

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

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

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

  115. trait FieldMirror extends AnyRef

    A mirror that reflects a field.

  116. class FilterTreeTraverser extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  117. 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
    Types
  118. class FindTreeTraverser extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  119. 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
    Types
  120. case class FixedMirrorTreeCreator extends TreeCreator with Product with Serializable

    Definition Classes
    StdCreators
  121. case class FixedMirrorTypeCreator extends TypeCreator with Product with Serializable

    Definition Classes
    StdCreators
  122. 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
  123. 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
  124. trait FlagOps extends Any

    The API of FlagSet instances.

  125. trait FlagValues extends AnyRef

    All possible values that can constitute flag sets.

  126. class ForEachTypeTraverser extends internal.SymbolTable.TypeTraverser

    Definition Classes
    Types
  127. class ForeachPartialTreeTraverser extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  128. class ForeachTreeTraverser extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  129. trait FreeSymbol extends internal.SymbolTable.Symbol

    Definition Classes
    Symbols
  130. class FreeTermSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.FreeSymbol with internal.SymbolTable.FreeTermSymbolApi

    The type of free terms introduced by reification.

    The type of free terms introduced by reification.

    Definition Classes
    Symbols → Symbols
  131. trait FreeTermSymbolApi extends Universe.TermSymbolApi

    The API of free term symbols.

  132. class FreeTypeSymbol extends internal.SymbolTable.TypeSkolem with internal.SymbolTable.FreeSymbol with internal.SymbolTable.FreeTypeSymbolApi

    The type of free types introduced by reification.

    The type of free types introduced by reification.

    Definition Classes
    Symbols → Symbols
  133. trait FreeTypeSymbolApi extends Universe.TypeSymbolApi

    The API of free type symbols.

  134. case class Function extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.FunctionApi with Product with Serializable

    Anonymous function, eliminated by compiler phase lambdalift

    Anonymous function, eliminated by compiler phase lambdalift

    Definition Classes
    Trees → Trees
  135. trait FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi

    The API that all functions support

  136. abstract class FunctionExtractor extends AnyRef

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

  137. abstract class GenericApply extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.GenericApplyApi

    Common base class for Apply and TypeApply.

    Common base class for Apply and TypeApply.

    Definition Classes
    Trees → Trees
  138. trait GenericApplyApi extends Universe.TermTreeApi

    The API that all applies support

  139. class HKTypeVar extends internal.SymbolTable.TypeVar

    Precondition: params.

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

    Definition Classes
    Types
  140. case class Ident extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.IdentContextApi with Product with Serializable

    A reference to identifier name.

    A reference to identifier name.

    Definition Classes
    Trees → Trees
  141. trait IdentApi extends Universe.RefTreeApi

    The API that all idents support

  142. trait IdentContextApi extends IdentApi

    The extended API of idents that's supported in macro context universes

  143. abstract class IdentExtractor extends AnyRef

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

  144. case class If extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.IfApi with Product with Serializable

    Conditional expression

    Conditional expression

    Definition Classes
    Trees → Trees
  145. trait IfApi extends Universe.TermTreeApi

    The API that all ifs support

  146. abstract class IfExtractor extends AnyRef

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

  147. trait ImplClassSymbol extends internal.SymbolTable.ClassSymbol

    Definition Classes
    Symbols
  148. abstract class ImplDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.ImplDefApi

    A common base class for class and object definitions.

    A common base class for class and object definitions.

    Definition Classes
    Trees → Trees
  149. trait ImplDefApi extends Universe.MemberDefApi

    The API that all impl defs support

  150. case class Import extends internal.SymbolTable.SymTree with internal.SymbolTable.ImportApi with Product with Serializable

    Import clause

    Import clause

    Definition Classes
    Trees → Trees
  151. trait ImportApi extends Universe.SymTreeApi

    The API that all imports support

  152. abstract class ImportExtractor extends AnyRef

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

  153. case class ImportSelector extends internal.SymbolTable.ImportSelectorApi with Product with Serializable

    Import selector

    Import selector

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

    Eliminated by typecheck.

    Definition Classes
    Trees → Trees
  154. trait ImportSelectorApi extends AnyRef

    The API that all import selectors support

  155. abstract class ImportSelectorExtractor extends AnyRef

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

  156. trait Importer extends AnyRef

    The API of importers.

  157. abstract class InfoTransformer extends AnyRef

    Definition Classes
    InfoTransformers
  158. trait InstanceMirror extends AnyRef

    A mirror that reflects a runtime value.

  159. 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
    Types
  160. abstract class InternalTreeCopierOps extends internal.SymbolTable.TreeCopierOps

    Definition Classes
    Trees
  161. trait JavaClassCompleter extends SymbolTable.LazyType with SymbolTable.FlagAssigningCompleter

    Definition Classes
    JavaMirrors
  162. class JavaKeywords extends AnyRef

    Definition Classes
    StdNames
  163. class JavaMethodType extends internal.SymbolTable.MethodType

    Definition Classes
    Types
  164. 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 → JavaMirrors
  165. trait KeepOnlyTypeConstraints extends internal.SymbolTable.TypeMap with internal.SymbolTable.AnnotationFilter

    Definition Classes
    Types
  166. 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
  167. case class KindErrors extends Product with Serializable

    Definition Classes
    Kinds
  168. case class LabelDef extends internal.SymbolTable.DefTree with internal.SymbolTable.TermTree with internal.SymbolTable.LabelDefApi with Product with Serializable

    A labelled expression.

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

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

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

    Forward jumps within a block are allowed.

    Definition Classes
    Trees → Trees
  169. trait LabelDefApi extends Universe.DefTreeApi with Universe.TermTreeApi

    The API that all label defs support

  170. abstract class LabelDefExtractor extends AnyRef

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

  171. final 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
  172. class LazyPackageType extends SymbolTable.LazyType with SymbolTable.FlagAgnosticCompleter

    The type completer for packages.

    The type completer for packages.

    Definition Classes
    SymbolLoaders
  173. abstract class LazyPolyType extends internal.SymbolTable.LazyType

    Definition Classes
    Types
  174. class LazyTreeCopier extends internal.SymbolTable.InternalTreeCopierOps

    Definition Classes
    Trees
  175. 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
  176. case class Literal extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.LiteralApi with Product with Serializable

    Literal

    Literal

    Definition Classes
    Trees → Trees
  177. case class LiteralAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with internal.SymbolTable.LiteralArgumentApi 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
  178. trait LiteralApi extends Universe.TermTreeApi

    The API that all literals support

  179. trait LiteralArgumentApi extends AnyRef

    The API of LiteralArgument instances.

  180. abstract class LiteralArgumentExtractor extends AnyRef

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

  181. abstract class LiteralExtractor extends AnyRef

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

  182. case class MacroExpansionAttachment extends Product with Serializable

    Is added by the macro engine to the results of macro expansions.

    Is added by the macro engine to the results of macro expansions. Stores the original expandee as it entered the macroExpand function.

    Definition Classes
    StdAttachments
  183. class MalformedType extends internal.SymbolTable.TypeError

    A throwable signalling a malformed type

    A throwable signalling a malformed type

    Definition Classes
    Types
  184. class MappedBaseTypeSeq extends internal.SymbolTable.BaseTypeSeq

    Definition Classes
    BaseTypeSeqs
  185. case class Match extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.MatchApi with Product with Serializable

    - Pattern matching expression (before compiler phase explicitouter before 2.

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

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

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

    • all guards are EmptyTree,
    • all patterns will be either Literal(Constant(x:Int)) or Alternative(lit|...|lit)
    • except for an "otherwise" branch, which has pattern Ident(nme.WILDCARD)
    Definition Classes
    Trees → Trees
  186. trait MatchApi extends Universe.TermTreeApi

    The API that all matches support

  187. abstract class MatchExtractor extends AnyRef

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

  188. abstract class MemberDef extends internal.SymbolTable.DefTree with internal.SymbolTable.MemberDefApi

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

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

    Definition Classes
    Trees → Trees
  189. trait MemberDefApi extends Universe.DefTreeApi

    The API that all member defs support

  190. trait MemberScopeApi extends Universe.ScopeApi

    The API that all member scopes support

  191. trait MethodMirror extends AnyRef

    A mirror that reflects a method.

  192. class MethodSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.MethodSymbolApi

    A class for method symbols

    A class for method symbols

    Definition Classes
    Symbols → Symbols
  193. trait MethodSymbolApi extends Universe.TermSymbolApi

    The API of method symbols.

  194. 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 → Types
  195. trait MethodTypeApi extends Universe.TypeApi

    The API that all method types support.

  196. abstract class MethodTypeExtractor extends AnyRef

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

  197. type Mirror = JavaMirror

    In runtime reflection universes, mirrors are JavaMirrors.

    In runtime reflection universes, mirrors are JavaMirrors.

    Definition Classes
    JavaMirrors → JavaMirrors → Mirrors → Mirrors
  198. class MissingAliasControl extends Throwable with ControlThrowable

    Definition Classes
    Types
  199. class MissingTypeControl extends Throwable with ControlThrowable

    Definition Classes
    Types
  200. case class Modifiers extends internal.SymbolTable.ModifiersApi with HasFlags with Product with Serializable

    Definition Classes
    Trees → Trees
  201. abstract class ModifiersApi extends AnyRef

    The API that all Modifiers support

  202. abstract class ModifiersCreator extends AnyRef

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

  203. 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
  204. case class ModuleDef extends internal.SymbolTable.ImplDef with internal.SymbolTable.ModuleDefApi with Product with Serializable

    An object definition, e.

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

    Definition Classes
    Trees → Trees
  205. trait ModuleDefApi extends Universe.ImplDefApi

    The API that all module defs support

  206. abstract class ModuleDefExtractor extends AnyRef

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

  207. trait ModuleMirror extends Universe.TemplateMirror

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

  208. class ModuleSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.ModuleSymbolApi

    A class for module symbols

    A class for module symbols

    Definition Classes
    Symbols → Symbols
  209. trait ModuleSymbolApi extends Universe.TermSymbolApi

    The API of module symbols.

  210. class ModuleTypeRef extends internal.SymbolTable.NoArgsTypeRef with internal.SymbolTable.ClassTypeRef

    Definition Classes
    Types
  211. sealed abstract class Name extends internal.Names.NameApi

    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 → Names
  212. abstract class NameApi extends AnyRef

    The API of Name instances.

  213. final class NameOps[T <: Name] extends AnyRef

    Definition Classes
    Names
  214. trait NameTree extends internal.SymbolTable.Tree with internal.SymbolTable.NameTreeApi

    A tree with a name - effectively, a DefTree or RefTree.

    A tree with a name - effectively, a DefTree or RefTree.

    Definition Classes
    Trees → Trees
  215. trait NameTreeApi extends Universe.TreeApi

    The API that all name trees support

  216. 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
  217. trait NamesApi extends AnyRef

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

  218. case class NestedAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with internal.SymbolTable.NestedArgumentApi with Product with Serializable

    Represents a nested classfile annotation

    Represents a nested classfile annotation

    Definition Classes
    AnnotationInfos
  219. trait NestedArgumentApi extends AnyRef

    API of NestedArgument instances.

  220. abstract class NestedArgumentExtractor extends AnyRef

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

  221. case class New extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.NewApi with Product with Serializable

    Object instantiation

    Object instantiation

    Definition Classes
    Trees → Trees
  222. trait NewApi extends Universe.TermTreeApi

    The API that all news support

  223. abstract class NewExtractor extends AnyRef

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

  224. class NoArgsTypeRef extends internal.SymbolTable.TypeRef

    Definition Classes
    Types
  225. class NoCommonType extends Throwable with ControlThrowable

    Definition Classes
    Types
  226. class NoSymbol extends internal.SymbolTable.Symbol

    An object representing a missing symbol

    An object representing a missing symbol

    Definition Classes
    Symbols
  227. trait NonClassTypeRef extends internal.SymbolTable.TypeRef

    Definition Classes
    Types
  228. case class NotNullType extends internal.SymbolTable.SubType with internal.SymbolTable.RewrappingTypeProxy with Product with Serializable

    Definition Classes
    Types
  229. case class NullaryMethodType extends internal.SymbolTable.Type with internal.SymbolTable.NullaryMethodTypeApi with Product with Serializable

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

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

    Definition Classes
    Types → Types
  230. trait NullaryMethodTypeApi extends Universe.TypeApi

    The API that all nullary method types support.

  231. abstract class NullaryMethodTypeExtractor extends AnyRef

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

  232. 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
  233. class PackageClassInfoType extends internal.SymbolTable.ClassInfoType

    Definition Classes
    Types
  234. class PackageClassSymbol extends internal.SymbolTable.ModuleClassSymbol

    Definition Classes
    Symbols
  235. case class PackageDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.PackageDefApi with Product with Serializable

    A packaging, such as package pid { stats }

    A packaging, such as package pid { stats }

    Definition Classes
    Trees → Trees
  236. trait PackageDefApi extends Universe.MemberDefApi

    The API that all package defs support

  237. abstract class PackageDefExtractor extends AnyRef

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

  238. class PackageObjectClassSymbol extends internal.SymbolTable.ModuleClassSymbol

    Definition Classes
    Symbols
  239. class PackageScope extends SymbolTable.Scope with SymbolTable.SynchronizedScope

    Definition Classes
    SymbolLoaders
  240. class PackageTypeRef extends internal.SymbolTable.ModuleTypeRef

    Definition Classes
    Types
  241. 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
  242. 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 → Types
  243. trait PolyTypeApi extends Universe.TypeApi

    The API that all polymorphic types support.

  244. abstract class PolyTypeExtractor extends AnyRef

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

  245. trait PosAssigner extends internal.SymbolTable.Traverser

    Definition Classes
    Positions
  246. 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
  247. class RawTreePrinter extends internal.SymbolTable.TreePrinter

    Definition Classes
    Printers
  248. 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
  249. trait RefTree extends internal.SymbolTable.SymTree with internal.SymbolTable.NameTree with internal.SymbolTable.RefTreeApi

    A tree which references a symbol-carrying entity.

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

    Definition Classes
    Trees → Trees
  250. trait RefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

    The API that all ref trees support

  251. case class ReferenceToBoxed extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.ReferenceToBoxedApi with Product with Serializable

    Marks underlying reference to id as boxed.

    Marks underlying reference to id as boxed.

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

    Definition Classes
    Trees → Trees
  252. trait ReferenceToBoxedApi extends Universe.TermTreeApi

    The API that all references support

  253. abstract class ReferenceToBoxedExtractor extends AnyRef

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

  254. 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 → Types
  255. final class RefinedType0 extends internal.SymbolTable.RefinedType

    Definition Classes
    Types
  256. trait RefinedTypeApi extends Universe.TypeApi

    The API that all refined types support.

  257. 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.

  258. class RefinementClassSymbol extends internal.SymbolTable.ClassSymbol

    Definition Classes
    Symbols
  259. class RefinementTypeRef extends internal.SymbolTable.NoArgsTypeRef with internal.SymbolTable.ClassTypeRef

    Definition Classes
    Types
  260. trait ReflectiveMirror extends api.Mirror[Mirrors.this.type]

    A mirror that reflects instances and static classes.

  261. case class Return extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.ReturnApi with Product with Serializable

    Return expression

    Return expression

    Definition Classes
    Trees → Trees
  262. trait ReturnApi extends Universe.TermTreeApi

    The API that all returns support

  263. abstract class ReturnExtractor extends AnyRef

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

  264. 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
  265. trait RootSymbol extends internal.SymbolTable.Symbol

    Definition Classes
    Mirrors
  266. abstract class Roots extends internal.SymbolTable.RootsBase

    Definition Classes
    Mirrors
  267. abstract class RootsBase extends api.Mirror[Mirrors.this.type]

    Definition Classes
    Mirrors
  268. abstract type Run <: RunContextApi

    The type of compilation runs.

  269. trait RunContextApi extends AnyRef

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

  270. type RunId = Int

    An ordinal number for compiler runs.

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

    Definition Classes
    SymbolTable
  271. 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
    JavaMirrors → JavaMirrorsMirrors
  272. trait RuntimeMirror extends api.Mirror[Mirrors.this.type] with Universe.ReflectiveMirror

    The API of a mirror for a reflective universe.

  273. case class ScalaSigBytes extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable

    A specific annotation argument that encodes an array of bytes as an array of Long.

    A specific annotation argument that encodes an array of bytes as an array of Long. The type of the argument declared in the annotation must be String. This specialised class is used to encode Scala signatures for reasons of efficiency, both in term of class-file size and in term of compiler performance.

    Definition Classes
    AnnotationInfos
  274. class Scope extends 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 → Scopes
  275. trait ScopeApi extends Iterable[Universe.Symbol]

    The API that all scopes support

  276. class ScopeEntry extends AnyRef

    Definition Classes
    Scopes
  277. case class Select extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.SelectApi with Product with Serializable

    A member selection <qualifier> .

    A member selection <qualifier> . <name>

    Definition Classes
    Trees → Trees
  278. trait SelectApi extends Universe.RefTreeApi

    The API that all selects support

  279. abstract class SelectExtractor extends AnyRef

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

  280. case class SelectFromTypeTree extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.TypTree with internal.SymbolTable.SelectFromTypeTreeApi with Product with Serializable

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

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

    Definition Classes
    Trees → Trees
  281. trait SelectFromTypeTreeApi extends Universe.TypTreeApi with Universe.RefTreeApi

    The API that all selects from type trees support

  282. abstract class SelectFromTypeTreeExtractor extends AnyRef

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

  283. 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
  284. 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 → Types
  285. trait SingleTypeApi extends Universe.TypeApi

    The API that all single types support.

  286. 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.

  287. abstract class SingletonType extends internal.SymbolTable.SubType with internal.SymbolTable.SimpleTypeProxy

    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 → Types
  288. case class SingletonTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.SingletonTypeTreeApi with Product with Serializable

    Singleton type, eliminated by RefCheck

    Singleton type, eliminated by RefCheck

    Definition Classes
    Trees → Trees
  289. trait SingletonTypeTreeApi extends Universe.TypTreeApi

    The API that all singleton type trees support

  290. abstract class SingletonTypeTreeExtractor extends AnyRef

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

  291. abstract class StandardImporter extends internal.SymbolTable.Importer

    Definition Classes
    Importers
  292. trait StandardTypes extends AnyRef

    Defines standard types.

  293. case class Star extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.StarApi with Product with Serializable

    Repetition of pattern.

    Repetition of pattern.

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

    Definition Classes
    Trees → Trees
  294. trait StarApi extends Universe.TermTreeApi

    The API that all stars support

  295. abstract class StarExtractor extends AnyRef

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

  296. class StrictTreeCopier extends internal.SymbolTable.InternalTreeCopierOps

    Definition Classes
    Trees
  297. class StubClassSymbol extends internal.SymbolTable.ClassSymbol with internal.SymbolTable.StubSymbol

    Definition Classes
    Symbols
  298. trait StubSymbol extends internal.SymbolTable.Symbol

    Definition Classes
    Symbols
  299. class StubTermSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.StubSymbol

    Definition Classes
    Symbols
  300. 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
  301. class SubTypePair extends AnyRef

    Definition Classes
    Types
  302. abstract class SubstMap[T] extends internal.SymbolTable.TypeMap

    A base class to compute all substitutions

    A base class to compute all substitutions

    Definition Classes
    Types
  303. 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
    Types
  304. class SubstThisMap extends internal.SymbolTable.TypeMap

    A map to implement the substThis method.

    A map to implement the substThis method.

    Definition Classes
    Types
  305. 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
    Types
  306. class SubstWildcardMap extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  307. case class Super extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.SuperApi with Product with Serializable

    Super reference, where qual is the corresponding this reference.

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

    Definition Classes
    Trees → Trees
  308. trait SuperApi extends Universe.TermTreeApi

    The API that all supers support

  309. abstract class SuperExtractor extends AnyRef

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

  310. abstract case class SuperType extends internal.SymbolTable.SingletonType with internal.SymbolTable.SuperTypeApi with Product with Serializable

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

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

    SuperType(thistpe, supertpe)

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

    Definition Classes
    Types → Types
  311. trait SuperTypeApi extends Universe.TypeApi

    The API that all super types support.

  312. abstract class SuperTypeExtractor extends AnyRef

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

  313. abstract class SymLoader extends internal.SymbolTable.LazyType

    Definition Classes
    SymbolTable
  314. abstract class SymTree extends internal.SymbolTable.Tree with internal.SymbolTable.SymTreeContextApi

    A tree with a mutable symbol field, initialized to NoSymbol.

    A tree with a mutable symbol field, initialized to NoSymbol.

    Definition Classes
    Trees → Trees
  315. trait SymTreeApi extends Universe.TreeApi

    The API that all sym trees support

  316. trait SymTreeContextApi extends SymTreeApi

    The extended API of sym trees that's supported in macro context universes

  317. 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 → Symbols
  318. trait SymbolApi extends AnyRef

    The API of symbols.

  319. trait SymbolContextApi extends SymbolApi with AttachableApi

    The extended API of symbols that's supported in macro context universes

  320. abstract class SymbolContextApiImpl extends internal.SymbolTable.SymbolContextApi

    Definition Classes
    Symbols
  321. abstract class SymbolNames extends AnyRef

    Definition Classes
    StdNames
  322. trait SynchronizedBaseTypeSeq extends SymbolTable.BaseTypeSeq

    Definition Classes
    SynchronizedOps
  323. trait SynchronizedClassSymbol extends SymbolTable.ClassSymbol with SymbolTable.SynchronizedTypeSymbol

    Definition Classes
    SynchronizedSymbols
  324. trait SynchronizedMethodSymbol extends SymbolTable.MethodSymbol with SymbolTable.SynchronizedTermSymbol

    Definition Classes
    SynchronizedSymbols
  325. trait SynchronizedModuleClassSymbol extends SymbolTable.ModuleClassSymbol with SymbolTable.SynchronizedClassSymbol

    Definition Classes
    SynchronizedSymbols
  326. trait SynchronizedScope extends SymbolTable.Scope

    Definition Classes
    SynchronizedOps
  327. trait SynchronizedSymbol extends SymbolTable.Symbol

    Definition Classes
    SynchronizedSymbols
  328. trait SynchronizedTermSymbol extends SymbolTable.TermSymbol with SymbolTable.SynchronizedSymbol

    Definition Classes
    SynchronizedSymbols
  329. trait SynchronizedTypeSymbol extends SymbolTable.TypeSymbol with SymbolTable.SynchronizedSymbol

    Definition Classes
    SynchronizedSymbols
  330. class SynchronizedUndoLog extends SymbolTable.UndoLog

    Definition Classes
    SynchronizedTypes
  331. case class Template extends internal.SymbolTable.SymTree with internal.SymbolTable.TemplateApi with Product with Serializable

    Instantiation template of a class or trait

    Instantiation template of a class or trait

    Definition Classes
    Trees → Trees
  332. trait TemplateApi extends Universe.SymTreeApi

    The API that all templates support

  333. abstract class TemplateExtractor extends AnyRef

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

  334. trait TemplateMirror extends AnyRef

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

  335. sealed abstract class TermName extends Name

    The abstract type of names representing types.

    The abstract type of names representing types.

    Definition Classes
    Names → Names
  336. abstract class TermNames extends internal.SymbolTable.Keywords with internal.SymbolTable.TermNamesApi

    Definition Classes
    StdNames
  337. trait TermNamesApi extends Universe.NamesApi

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

  338. class TermSymbol extends internal.SymbolTable.Symbol with internal.SymbolTable.TermSymbolApi

    A class for term symbols

    A class for term symbols

    Definition Classes
    Symbols → Symbols
  339. trait TermSymbolApi extends Universe.SymbolApi

    The API of term symbols.

  340. trait TermTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTreeApi

    A tree for a term.

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

    Definition Classes
    Trees → Trees
  341. trait TermTreeApi extends Universe.TreeApi

    The API that all term trees support

  342. case class This extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.ThisApi with Product with Serializable

    Self reference

    Self reference

    Definition Classes
    Trees → Trees
  343. trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi

    The API that all thises support

  344. abstract class ThisExtractor extends AnyRef

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

  345. class ThisSubstituter extends internal.SymbolTable.Transformer

    Substitute clazz.

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

    Definition Classes
    Trees
  346. 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>.

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

    Definition Classes
    Types → Types
  347. trait ThisTypeApi extends Universe.TypeApi

    The API that all this types support.

  348. 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.

  349. case class Throw extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.ThrowApi with Product with Serializable

    Throw expression

    Throw expression

    Definition Classes
    Trees → Trees
  350. trait ThrowApi extends Universe.TermTreeApi

    The API that all tries support

  351. abstract class ThrowExtractor extends AnyRef

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

  352. 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
  353. abstract class Transformer extends AnyRef

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

  354. class Traverser extends AnyRef

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

  355. abstract class Tree extends internal.SymbolTable.TreeContextApiImpl with internal.SymbolTable.Attachable with Product

    The type of Scala abstract syntax trees.

    The type of Scala abstract syntax trees.

    Definition Classes
    Trees → Trees
  356. trait TreeApi extends Product

    The API that all trees support.

  357. trait TreeContextApi extends TreeApi with AttachableApi

    The extended API of trees that's supported in macro context universes

  358. abstract class TreeContextApiImpl extends internal.SymbolTable.TreeContextApi

    Definition Classes
    Trees
  359. type TreeCopier = InternalTreeCopierOps

    The type of standard (lazy) tree copiers.

  360. abstract class TreeCopierOps extends AnyRef

    The API of a tree copier.

  361. class TreePrinter extends internal.SymbolTable.TreePrinter

    Definition Classes
    Printers → Printers
  362. trait TreeStackTraverser extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  363. class TreeSubstituter extends internal.SymbolTable.Transformer

    Definition Classes
    Trees
  364. class TreeSymSubstTraverser extends internal.SymbolTable.TypeMapTreeSubstituter

    Definition Classes
    Trees
  365. class TreeSymSubstituter extends internal.SymbolTable.Transformer

    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
  366. class TreeTypeSubstituter extends internal.SymbolTable.TypeMapTreeSubstituter

    Definition Classes
    Trees
  367. case class Try extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.TryApi with Product with Serializable

    Try catch node

    Try catch node

    Definition Classes
    Trees → Trees
  368. trait TryApi extends Universe.TermTreeApi

    The API that all tries support

  369. abstract class TryExtractor extends AnyRef

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

  370. trait TypTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTreeApi

    A tree for a type.

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

    Definition Classes
    Trees → Trees
  371. trait TypTreeApi extends Universe.TreeApi

    The API that all typ trees support

  372. 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 → Types
  373. abstract class TypeApi extends AnyRef

    The API of types.

  374. abstract class TypeApiImpl extends internal.SymbolTable.TypeApi

    Definition Classes
    Types
  375. case class TypeApply extends internal.SymbolTable.GenericApply with internal.SymbolTable.TypeApplyApi with Product with Serializable

    Explicit type application.

    Explicit type application.

    Definition Classes
    Trees → Trees
  376. trait TypeApplyApi extends Universe.GenericApplyApi

    The API that all type applies support

  377. abstract class TypeApplyExtractor extends AnyRef

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

  378. 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 → Types
  379. trait TypeBoundsApi extends Universe.TypeApi

    The API that all type bounds support.

  380. 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.

  381. case class TypeBoundsTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.TypeBoundsTreeApi with Product with Serializable

    Type bounds tree node

    Type bounds tree node

    Definition Classes
    Trees → Trees
  382. trait TypeBoundsTreeApi extends Universe.TypTreeApi

    The API that all type bound trees support

  383. abstract class TypeBoundsTreeExtractor extends AnyRef

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

  384. abstract class TypeCollector[T] extends internal.SymbolTable.TypeTraverser

    Definition Classes
    Types
  385. 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
    Types
  386. case class TypeDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.TypeDefApi with Product with Serializable

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

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

    Definition Classes
    Trees → Trees
  387. trait TypeDefApi extends Universe.MemberDefApi

    The API that all type defs support

  388. abstract class TypeDefExtractor extends AnyRef

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

  389. class TypeError extends Throwable

    A throwable signalling a type error

    A throwable signalling a type error

    Definition Classes
    Types
  390. 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
    Types
  391. class TypeMapTreeSubstituter extends internal.SymbolTable.Traverser

    Definition Classes
    Trees
  392. sealed abstract class TypeName extends Name

    The abstract type of names representing terms.

    The abstract type of names representing terms.

    Definition Classes
    Names → Names
  393. abstract class TypeNames extends internal.SymbolTable.Keywords with internal.SymbolTable.TypeNamesApi

    Definition Classes
    StdNames
  394. trait TypeNamesApi extends Universe.NamesApi

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

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

    Definition Classes
    Types → Types
  396. trait TypeRefApi extends Universe.TypeApi

    The API that all type refs support.

  397. 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 argumenrts.

  398. 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
  399. 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 → Symbols
  400. trait TypeSymbolApi extends Universe.SymbolApi

    The API of type symbols.

  401. 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.

  402. abstract class TypeTraverser extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  403. abstract class TypeTraverserWithResult[T] extends internal.SymbolTable.TypeTraverser

    Definition Classes
    Types
  404. case class TypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.TypeTreeContextApi with Product with Serializable

    A synthetic tree holding an arbitrary type.

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

    Definition Classes
    Trees → Trees
  405. trait TypeTreeApi extends Universe.TypTreeApi

    The API that all type trees support

  406. trait TypeTreeContextApi extends TypeTreeApi

    The extended API of sym trees that's supported in macro context universes

  407. abstract class TypeTreeExtractor extends AnyRef

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

  408. class TypeUnwrapper extends (internal.SymbolTable.Type) ⇒ internal.SymbolTable.Type

    Definition Classes
    Types
  409. 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
  410. case class Typed extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.TypedApi with Product with Serializable

    Type annotation, eliminated by compiler phase cleanup

    Type annotation, eliminated by compiler phase cleanup

    Definition Classes
    Trees → Trees
  411. trait TypedApi extends Universe.TermTreeApi

    The API that all typeds support

  412. abstract class TypedExtractor extends AnyRef

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

  413. case class UnApply extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.UnApplyApi with Product with Serializable

    Used to represent unapply methods in pattern matching.

    Used to represent unapply methods in pattern matching.

    For example:

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

    Is represented as:

    Match(
    Literal(Constant(2)),
    List(
      CaseDef(
        UnApply(
          // a dummy node that carries the type of unapplication to patmat
          // the  here doesn't have an underlying symbol
          // it only has a type assigned, therefore after `resetAllAttrs` this tree is no longer typeable
          Apply(Select(Ident(Foo), newTermName("unapply")), List(Ident(newTermName("")))),
          // arguments of the unapply => nothing synthetic here
          List(Bind(newTermName("x"), Ident(nme.WILDCARD)))),
        EmptyTree,
        Ident(newTermName("x")))))

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

    Definition Classes
    Trees → Trees
  414. trait UnApplyApi extends Universe.TermTreeApi

    The API that all unapplies support

  415. abstract class UnApplyExtractor extends AnyRef

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

  416. class UndoLog extends Clearable

    Definition Classes
    Types
  417. final class UniqueConstantType extends internal.SymbolTable.ConstantType

    Definition Classes
    Types
  418. final class UniqueErasedValueType extends internal.SymbolTable.ErasedValueType

    Definition Classes
    Types
  419. final class UniqueSingleType extends internal.SymbolTable.SingleType

    Definition Classes
    Types
  420. final class UniqueSuperType extends internal.SymbolTable.SuperType

    Definition Classes
    Types
  421. final class UniqueThisType extends internal.SymbolTable.ThisType

    Definition Classes
    Types
  422. abstract class UniqueType extends internal.SymbolTable.Type with Product

    A type that can be passed to unique(.

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

    Definition Classes
    Types
  423. final class UniqueTypeBounds extends internal.SymbolTable.TypeBounds

    Definition Classes
    Types
  424. trait UntouchableTypeVar extends internal.SymbolTable.TypeVar

    Definition Classes
    Types
  425. case class ValDef extends internal.SymbolTable.ValOrDefDef with internal.SymbolTable.ValDefApi with Product with Serializable

    Broadly speaking, a value definition.

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

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

    The API that all val defs support

  427. abstract class ValDefExtractor extends AnyRef

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

  428. abstract class ValOrDefDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.ValOrDefDefApi

    A common base class for ValDefs and DefDefs.

    A common base class for ValDefs and DefDefs.

    Definition Classes
    Trees → Trees
  429. trait ValOrDefDefApi extends Universe.MemberDefApi

    The API that all val defs and def defs support

  430. trait ValueClassDefinitions extends AnyRef

    Definition Classes
    Definitions
  431. trait VariantTypeMap extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  432. 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.

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Test two objects for inequality.

    Test two objects for inequality.

    returns

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

    Definition Classes
    Any
  3. final def ##(): Int

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

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

    returns

    a hash value consistent with ==

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

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

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

    Definition Classes
    AnyRef
  7. final def ==(arg0: Any): Boolean

    Test two objects for equality.

    Test two objects for equality. The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

    returns

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

    Definition Classes
    Any
  8. object Alternative extends internal.SymbolTable.AlternativeExtractor with Serializable

    The constructor/extractor for Alternative instances.

    The constructor/extractor for Alternative instances.

    Definition Classes
    Trees → Trees
  9. implicit val AlternativeTag: ClassTag[Alternative]

    A tag that preserves the identity of the Alternative abstract type from erasure.

    A tag that preserves the identity of the Alternative abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  10. object Annotated extends internal.SymbolTable.AnnotatedExtractor with Serializable

    The constructor/extractor for Annotated instances.

    The constructor/extractor for Annotated instances.

    Definition Classes
    Trees → Trees
  11. implicit val AnnotatedTag: ClassTag[Annotated]

    A tag that preserves the identity of the Annotated abstract type from erasure.

    A tag that preserves the identity of the Annotated abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  12. object AnnotatedType extends internal.SymbolTable.AnnotatedTypeExtractor with Serializable

    The constructor/extractor for AnnotatedType instances.

    The constructor/extractor for AnnotatedType instances.

    Definition Classes
    Types → Types
  13. implicit val AnnotatedTypeTag: ClassTag[AnnotatedType]

    A tag that preserves the identity of the AnnotatedType abstract type from erasure.

    A tag that preserves the identity of the AnnotatedType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  14. object Annotation extends internal.SymbolTable.AnnotationExtractor

    The constructor/extractor for Annotation instances.

    The constructor/extractor for Annotation instances.

    Definition Classes
    AnnotationInfos → Annotations
  15. object AnnotationInfo

    Definition Classes
    AnnotationInfos
  16. implicit val AnnotationTag: ClassTag[AnnotationInfo]

    A tag that preserves the identity of the Annotation abstract type from erasure.

    A tag that preserves the identity of the Annotation abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    AnnotationInfos → Annotations
  17. object AppliedTypeTree extends internal.SymbolTable.AppliedTypeTreeExtractor with Serializable

    The constructor/extractor for AppliedTypeTree instances.

    The constructor/extractor for AppliedTypeTree instances.

    Definition Classes
    Trees → Trees
  18. implicit val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]

    A tag that preserves the identity of the AppliedTypeTree abstract type from erasure.

    A tag that preserves the identity of the AppliedTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  19. def Apply(sym: Symbol, args: Tree*): Tree

    A factory method for Apply nodes.

    A factory method for Apply nodes.

    Definition Classes
    Trees → Trees
  20. object Apply extends internal.SymbolTable.ApplyExtractor with Serializable

    The constructor/extractor for Apply instances.

    The constructor/extractor for Apply instances.

    Definition Classes
    Trees → Trees
  21. 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
  22. implicit val ApplyTag: ClassTag[Apply]

    A tag that preserves the identity of the Apply abstract type from erasure.

    A tag that preserves the identity of the Apply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  23. object ApproximateDependentMap extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  24. object ArrayAnnotArg extends internal.SymbolTable.ArrayArgumentExtractor with Serializable

    Definition Classes
    AnnotationInfos
  25. val ArrayArgument: ArrayAnnotArg.type

    The constructor/extractor for ArrayArgument instances.

    The constructor/extractor for ArrayArgument instances.

    Definition Classes
    AnnotationInfos → Annotations
  26. implicit val ArrayArgumentTag: ClassTag[ArrayAnnotArg]

    A tag that preserves the identity of the ArrayArgument abstract type from erasure.

    A tag that preserves the identity of the ArrayArgument abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    AnnotationInfos → Annotations
  27. object Assign extends internal.SymbolTable.AssignExtractor with Serializable

    The constructor/extractor for Assign instances.

    The constructor/extractor for Assign instances.

    Definition Classes
    Trees → Trees
  28. object AssignOrNamedArg extends internal.SymbolTable.AssignOrNamedArgExtractor with Serializable

    The constructor/extractor for AssignOrNamedArg instances.

    The constructor/extractor for AssignOrNamedArg instances.

    Definition Classes
    Trees → Trees
  29. implicit val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

    A tag that preserves the identity of the AssignOrNamedArg abstract type from erasure.

    A tag that preserves the identity of the AssignOrNamedArg abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  30. implicit val AssignTag: ClassTag[Assign]

    A tag that preserves the identity of the Assign abstract type from erasure.

    A tag that preserves the identity of the Assign abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  31. object BackquotedIdentifierAttachment extends 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
  32. def Bind(sym: Symbol, body: Tree): Bind

    A factory method for Bind nodes.

    A factory method for Bind nodes.

    Definition Classes
    Trees → Trees
  33. object Bind extends internal.SymbolTable.BindExtractor with Serializable

    The constructor/extractor for Bind instances.

    The constructor/extractor for Bind instances.

    Definition Classes
    Trees → Trees
  34. implicit val BindTag: ClassTag[Bind]

    A tag that preserves the identity of the Bind abstract type from erasure.

    A tag that preserves the identity of the Bind abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  35. def Block(stats: Tree*): Block

    Block factory that flattens directly nested blocks.

    Block factory that flattens directly nested blocks.

    Definition Classes
    Trees → Trees
  36. object Block extends internal.SymbolTable.BlockExtractor with Serializable

    The constructor/extractor for Block instances.

    The constructor/extractor for Block instances.

    Definition Classes
    Trees → Trees
  37. implicit val BlockTag: ClassTag[Block]

    A tag that preserves the identity of the Block abstract type from erasure.

    A tag that preserves the identity of the Block abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  38. object BooleanFlag extends Serializable

  39. final val BooleanTag: Int(2)

    Definition Classes
    Constants
  40. object BoundedWildcardType extends internal.SymbolTable.BoundedWildcardTypeExtractor with Serializable

    The constructor/extractor for BoundedWildcardType instances.

    The constructor/extractor for BoundedWildcardType instances.

    Definition Classes
    Types → Types
  41. implicit val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]

    A tag that preserves the identity of the BoundedWildcardType abstract type from erasure.

    A tag that preserves the identity of the BoundedWildcardType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  42. final val ByteTag: Int(3)

    Definition Classes
    Constants
  43. def CaseDef(pat: Tree, body: Tree): CaseDef

    casedef shorthand

    casedef shorthand

    Definition Classes
    Trees → Trees
  44. object CaseDef extends internal.SymbolTable.CaseDefExtractor with Serializable

    The constructor/extractor for CaseDef instances.

    The constructor/extractor for CaseDef instances.

    Definition Classes
    Trees → Trees
  45. implicit val CaseDefTag: ClassTag[CaseDef]

    A tag that preserves the identity of the CaseDef abstract type from erasure.

    A tag that preserves the identity of the CaseDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  46. final val CharTag: Int(5)

    Definition Classes
    Constants
  47. def ClassDef(sym: Symbol, impl: Template): ClassDef

    sym

    the class symbol

    returns

    the implementation template

    Definition Classes
    Trees → Trees
  48. object ClassDef extends internal.SymbolTable.ClassDefExtractor with Serializable

    The constructor/extractor for ClassDef instances.

    The constructor/extractor for ClassDef instances.

    Definition Classes
    Trees → Trees
  49. implicit val ClassDefTag: ClassTag[ClassDef]

    A tag that preserves the identity of the ClassDef abstract type from erasure.

    A tag that preserves the identity of the ClassDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  50. object ClassInfoType extends internal.SymbolTable.ClassInfoTypeExtractor with Serializable

    The constructor/extractor for ClassInfoType instances.

    The constructor/extractor for ClassInfoType instances.

    Definition Classes
    Types → Types
  51. implicit val ClassInfoTypeTag: ClassTag[ClassInfoType]

    A tag that preserves the identity of the ClassInfoType abstract type from erasure.

    A tag that preserves the identity of the ClassInfoType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  52. implicit val ClassSymbolTag: ClassTag[ClassSymbol]

    A tag that preserves the identity of the ClassSymbol abstract type from erasure.

    A tag that preserves the identity of the ClassSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  53. final val ClazzTag: Int(12)

    Definition Classes
    Constants
  54. implicit val CompoundTypeTag: ClassTag[CompoundType]

    A tag that preserves the identity of the CompoundType abstract type from erasure.

    A tag that preserves the identity of the CompoundType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  55. object CompoundTypeTree extends internal.SymbolTable.CompoundTypeTreeExtractor with Serializable

    The constructor/extractor for CompoundTypeTree instances.

    The constructor/extractor for CompoundTypeTree instances.

    Definition Classes
    Trees → Trees
  56. implicit val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]

    A tag that preserves the identity of the CompoundTypeTree abstract type from erasure.

    A tag that preserves the identity of the CompoundTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  57. 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
  58. object Constant extends internal.SymbolTable.ConstantExtractor with Serializable

    The constructor/extractor for Constant instances.

    The constructor/extractor for Constant instances.

    Definition Classes
    Constants → Constants
  59. implicit val ConstantTag: ClassTag[Constant]

    A tag that preserves the identity of the Constant abstract type from erasure.

    A tag that preserves the identity of the Constant abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Constants → Constants
  60. object ConstantType extends internal.SymbolTable.ConstantTypeExtractor with Serializable

    The constructor/extractor for ConstantType instances.

    The constructor/extractor for ConstantType instances.

    Definition Classes
    Types → Types
  61. implicit val ConstantTypeTag: ClassTag[ConstantType]

    A tag that preserves the identity of the ConstantType abstract type from erasure.

    A tag that preserves the identity of the ConstantType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  62. val CyclicInheritance: java.lang.Throwable

    Definition Classes
    BaseTypeSeqs
  63. def DefDef(sym: Symbol, rhs: (List[List[Symbol]]) ⇒ Tree): DefDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  64. def DefDef(sym: Symbol, rhs: Tree): DefDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  65. def DefDef(sym: Symbol, mods: Modifiers, originalParamTpts: (Symbol) ⇒ Tree, rhs: Tree): DefDef

    A DefDef with original trees attached to the TypeTree of each parameter

    A DefDef with original trees attached to the TypeTree of each parameter

    Definition Classes
    Trees
  66. def DefDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  67. def DefDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  68. def DefDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  69. object DefDef extends internal.SymbolTable.DefDefExtractor with Serializable

    The constructor/extractor for DefDef instances.

    The constructor/extractor for DefDef instances.

    Definition Classes
    Trees → Trees
  70. implicit val DefDefTag: ClassTag[DefDef]

    A tag that preserves the identity of the DefDef abstract type from erasure.

    A tag that preserves the identity of the DefDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  71. implicit val DefTreeTag: ClassTag[DefTree]

    A tag that preserves the identity of the DefTree abstract type from erasure.

    A tag that preserves the identity of the DefTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  72. final val DoubleTag: Int(9)

    Definition Classes
    Constants
  73. object EmptyScope extends internal.SymbolTable.Scope

    The empty scope (immutable).

    The empty scope (immutable).

    Definition Classes
    Scopes
  74. object EmptyTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with Product with Serializable

    The empty tree

    The empty tree

    Definition Classes
    Trees → Trees
  75. lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter

    Definition Classes
    Trees
  76. final val EnumTag: Int(13)

    Definition Classes
    Constants
  77. object ErasedValueType extends Serializable

    Definition Classes
    Types
  78. object ErroneousCollector extends internal.SymbolTable.TypeCollector[Boolean]

    A map to implement the contains method.

    A map to implement the contains method.

    Definition Classes
    Types
  79. 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
  80. object ExistentialType extends internal.SymbolTable.ExistentialTypeExtractor with Serializable

    The constructor/extractor for ExistentialType instances.

    The constructor/extractor for ExistentialType instances.

    Definition Classes
    Types → Types
  81. implicit val ExistentialTypeTag: ClassTag[ExistentialType]

    A tag that preserves the identity of the ExistentialType abstract type from erasure.

    A tag that preserves the identity of the ExistentialType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  82. object ExistentialTypeTree extends internal.SymbolTable.ExistentialTypeTreeExtractor with Serializable

    The constructor/extractor for ExistentialTypeTree instances.

    The constructor/extractor for ExistentialTypeTree instances.

    Definition Classes
    Trees → Trees
  83. implicit val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]

    A tag that preserves the identity of the ExistentialTypeTree abstract type from erasure.

    A tag that preserves the identity of the ExistentialTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  84. object Expr extends Serializable

    Constructor/Extractor for Expr.

  85. 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
  86. implicit val FlagSetTag: ClassTag[FlagSet]

    A tag that preserves the identity of the FlagSet abstract type from erasure.

    A tag that preserves the identity of the FlagSet abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    FlagSets → FlagSets
  87. final val FloatTag: Int(8)

    Definition Classes
    Constants
  88. implicit val FreeTermSymbolTag: ClassTag[FreeTermSymbol]

    A tag that preserves the identity of the FreeTermSymbol abstract type from erasure.

    A tag that preserves the identity of the FreeTermSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  89. implicit val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]

    A tag that preserves the identity of the FreeTypeSymbol abstract type from erasure.

    A tag that preserves the identity of the FreeTypeSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  90. object Function extends internal.SymbolTable.FunctionExtractor with Serializable

    The constructor/extractor for Function instances.

    The constructor/extractor for Function instances.

    Definition Classes
    Trees → Trees
  91. implicit val FunctionTag: ClassTag[Function]

    A tag that preserves the identity of the Function abstract type from erasure.

    A tag that preserves the identity of the Function abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  92. 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) until we start tracking explicit kinds equivalent to typeFun (except that the latter requires tparams nonEmpty).

    PP to AM: I've co-opted this for where I know tparams may well be empty, and expecting to get back tpe in such cases. Re being "forgiving" below, can we instead say this is the canonical creator for polyTypes which may or may not be poly? (It filched the standard "canonical creator" name.)

    Definition Classes
    Types
  93. implicit val GenericApplyTag: ClassTag[GenericApply]

    A tag that preserves the identity of the GenericApply abstract type from erasure.

    A tag that preserves the identity of the GenericApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  94. val GlbFailure: java.lang.Throwable

    Definition Classes
    Types
  95. object HasTypeMember

    Definition Classes
    Types
  96. object HasTypeParams

    Definition Classes
    Types
  97. def Ident(sym: Symbol): Ident

    A factory method for Ident nodes.

    A factory method for Ident nodes.

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

    A factory method for Ident nodes.

    A factory method for Ident nodes.

    Definition Classes
    Trees → Trees
  99. object Ident extends internal.SymbolTable.IdentExtractor with Serializable

    The constructor/extractor for Ident instances.

    The constructor/extractor for Ident instances.

    Definition Classes
    Trees → Trees
  100. implicit val IdentTag: ClassTag[Ident]

    A tag that preserves the identity of the Ident abstract type from erasure.

    A tag that preserves the identity of the Ident abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  101. object If extends internal.SymbolTable.IfExtractor with Serializable

    The constructor/extractor for If instances.

    The constructor/extractor for If instances.

    Definition Classes
    Trees → Trees
  102. implicit val IfTag: ClassTag[If]

    A tag that preserves the identity of the If abstract type from erasure.

    A tag that preserves the identity of the If abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  103. implicit val ImplDefTag: ClassTag[ImplDef]

    A tag that preserves the identity of the ImplDef abstract type from erasure.

    A tag that preserves the identity of the ImplDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  104. object Import extends internal.SymbolTable.ImportExtractor with Serializable

    The constructor/extractor for Import instances.

    The constructor/extractor for Import instances.

    Definition Classes
    Trees → Trees
  105. object ImportSelector extends internal.SymbolTable.ImportSelectorExtractor with Serializable

    The constructor/extractor for ImportSelector instances.

    The constructor/extractor for ImportSelector instances.

    Definition Classes
    Trees → Trees
  106. implicit val ImportSelectorTag: ClassTag[ImportSelector]

    A tag that preserves the identity of the ImportSelector abstract type from erasure.

    A tag that preserves the identity of the ImportSelector abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  107. implicit val ImportTag: ClassTag[Import]

    A tag that preserves the identity of the Import abstract type from erasure.

    A tag that preserves the identity of the Import abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  108. final val IntTag: Int(6)

    Definition Classes
    Constants
  109. object IsDependentCollector extends internal.SymbolTable.TypeCollector[Boolean]

    Definition Classes
    Types
  110. implicit val JavaArgumentTag: ClassTag[ClassfileAnnotArg]

    A tag that preserves the identity of the JavaArgument abstract type from erasure.

    A tag that preserves the identity of the JavaArgument abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    AnnotationInfos → Annotations
  111. def JavaMethodType(params: List[Symbol], resultType: Type): JavaMethodType

    The canonical creator for implicit method types

    The canonical creator for implicit method types

    Definition Classes
    Types
  112. def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef

    A factory method for LabelDef nodes.

    A factory method for LabelDef nodes.

    Definition Classes
    Trees → Trees
  113. object LabelDef extends internal.SymbolTable.LabelDefExtractor with Serializable

    The constructor/extractor for LabelDef instances.

    The constructor/extractor for LabelDef instances.

    Definition Classes
    Trees → Trees
  114. implicit val LabelDefTag: ClassTag[LabelDef]

    A tag that preserves the identity of the LabelDef abstract type from erasure.

    A tag that preserves the identity of the LabelDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  115. object Literal extends internal.SymbolTable.LiteralExtractor with Serializable

    The constructor/extractor for Literal instances.

    The constructor/extractor for Literal instances.

    Definition Classes
    Trees → Trees
  116. object LiteralAnnotArg extends internal.SymbolTable.LiteralArgumentExtractor with Serializable

    Definition Classes
    AnnotationInfos
  117. val LiteralArgument: LiteralAnnotArg.type

    The constructor/extractor for LiteralArgument instances.

    The constructor/extractor for LiteralArgument instances.

    Definition Classes
    AnnotationInfos → Annotations
  118. implicit val LiteralArgumentTag: ClassTag[LiteralAnnotArg]

    A tag that preserves the identity of the LiteralArgument abstract type from erasure.

    A tag that preserves the identity of the LiteralArgument abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    AnnotationInfos → Annotations
  119. implicit val LiteralTag: ClassTag[Literal]

    A tag that preserves the identity of the Literal abstract type from erasure.

    A tag that preserves the identity of the Literal abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  120. final val LongTag: Int(7)

    Definition Classes
    Constants
  121. object Match extends internal.SymbolTable.MatchExtractor with Serializable

    The constructor/extractor for Match instances.

    The constructor/extractor for Match instances.

    Definition Classes
    Trees → Trees
  122. implicit val MatchTag: ClassTag[Match]

    A tag that preserves the identity of the Match abstract type from erasure.

    A tag that preserves the identity of the Match abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  123. implicit val MemberDefTag: ClassTag[MemberDef]

    A tag that preserves the identity of the MemberDef abstract type from erasure.

    A tag that preserves the identity of the MemberDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  124. implicit val MemberScopeTag: ClassTag[MemberScope]

    A tag that preserves the identity of the MemberScope abstract type from erasure.

    A tag that preserves the identity of the MemberScope abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Scopes → Scopes
  125. implicit val MethodSymbolTag: ClassTag[MethodSymbol]

    A tag that preserves the identity of the MethodSymbol abstract type from erasure.

    A tag that preserves the identity of the MethodSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  126. object MethodType extends internal.SymbolTable.MethodTypeExtractor with Serializable

    The constructor/extractor for MethodType instances.

    The constructor/extractor for MethodType instances.

    Definition Classes
    Types → Types
  127. implicit val MethodTypeTag: ClassTag[MethodType]

    A tag that preserves the identity of the MethodType abstract type from erasure.

    A tag that preserves the identity of the MethodType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  128. def Modifiers(flags: FlagSet): Modifiers

    The factory for Modifiers instances.

    The factory for Modifiers instances.

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

    The factory for Modifiers instances.

    The factory for Modifiers instances.

    Definition Classes
    Trees
  130. object Modifiers extends internal.SymbolTable.ModifiersCreator with Serializable

    The constructor/extractor for Modifiers instances.

    The constructor/extractor for Modifiers instances.

    Definition Classes
    Trees → Trees
  131. implicit val ModifiersTag: ClassTag[Modifiers]

    A tag that preserves the identity of the Modifiers abstract type from erasure.

    A tag that preserves the identity of the Modifiers abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  132. def ModuleDef(sym: Symbol, impl: Template): ModuleDef

    sym

    the class symbol

    impl

    the implementation template

    Definition Classes
    Trees → Trees
  133. object ModuleDef extends internal.SymbolTable.ModuleDefExtractor with Serializable

    The constructor/extractor for ModuleDef instances.

    The constructor/extractor for ModuleDef instances.

    Definition Classes
    Trees → Trees
  134. implicit val ModuleDefTag: ClassTag[ModuleDef]

    A tag that preserves the identity of the ModuleDef abstract type from erasure.

    A tag that preserves the identity of the ModuleDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  135. implicit val ModuleSymbolTag: ClassTag[ModuleSymbol]

    A tag that preserves the identity of the ModuleSymbol abstract type from erasure.

    A tag that preserves the identity of the ModuleSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  136. implicit val NameTag: ClassTag[Name]

    A tag that preserves the identity of the Name abstract type from erasure.

    A tag that preserves the identity of the Name abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Names → Names
  137. implicit val NameTreeTag: ClassTag[NameTree]

    A tag that preserves the identity of the NameTree abstract type from erasure.

    A tag that preserves the identity of the NameTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  138. object NestedAnnotArg extends internal.SymbolTable.NestedArgumentExtractor with Serializable

    Definition Classes
    AnnotationInfos
  139. val NestedArgument: NestedAnnotArg.type

    The constructor/extractor for NestedArgument instances.

    The constructor/extractor for NestedArgument instances.

    Definition Classes
    AnnotationInfos → Annotations
  140. implicit val NestedArgumentTag: ClassTag[NestedAnnotArg]

    A tag that preserves the identity of the NestedArgument abstract type from erasure.

    A tag that preserves the identity of the NestedArgument abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    AnnotationInfos → Annotations
  141. 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
  142. 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
  143. 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
  144. object New extends internal.SymbolTable.NewExtractor with Serializable

    The constructor/extractor for New instances.

    The constructor/extractor for New instances.

    Definition Classes
    Trees → Trees
  145. implicit val NewTag: ClassTag[New]

    A tag that preserves the identity of the New abstract type from erasure.

    A tag that preserves the identity of the New abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  146. val NoFlags: FlagSet

    The empty set of flags

    The empty set of flags

    Definition Classes
    FlagSets → FlagSets
  147. val NoKindErrors: KindErrors

    Definition Classes
    Kinds
  148. 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
  149. final val NoPeriod: Int(0)

    Definition Classes
    SymbolTable
  150. val NoPosition: internal.util.NoPosition.type

    A special "missing" position.

    A special "missing" position.

    Definition Classes
    Positions → Positions
  151. 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
  152. final val NoRunId: Int(0)

    Definition Classes
    SymbolTable
  153. lazy val NoSymbol: NoSymbol

    Definition Classes
    Symbols → Symbols
  154. final val NoTag: Int(0)

    Definition Classes
    Constants
  155. 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
  156. final val NullTag: Int(11)

    Definition Classes
    Constants
  157. object NullaryMethodType extends internal.SymbolTable.NullaryMethodTypeExtractor with Serializable

    The constructor/extractor for NullaryMethodType instances.

    The constructor/extractor for NullaryMethodType instances.

    Definition Classes
    Types → Types
  158. implicit val NullaryMethodTypeTag: ClassTag[NullaryMethodType]

    A tag that preserves the identity of the NullaryMethodType abstract type from erasure.

    A tag that preserves the identity of the NullaryMethodType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  159. object PackageDef extends internal.SymbolTable.PackageDefExtractor with Serializable

    The constructor/extractor for PackageDef instances.

    The constructor/extractor for PackageDef instances.

    Definition Classes
    Trees → Trees
  160. implicit val PackageDefTag: ClassTag[PackageDef]

    A tag that preserves the identity of the PackageDef abstract type from erasure.

    A tag that preserves the identity of the PackageDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  161. object PolyType extends internal.SymbolTable.PolyTypeExtractor with Serializable

    The constructor/extractor for PolyType instances.

    The constructor/extractor for PolyType instances.

    Definition Classes
    Types → Types
  162. implicit val PolyTypeTag: ClassTag[PolyType]

    A tag that preserves the identity of the PolyType abstract type from erasure.

    A tag that preserves the identity of the PolyType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  163. implicit val PositionTag: ClassTag[Position]

    A tag that preserves the identity of the Position abstract type from erasure.

    A tag that preserves the identity of the Position abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Positions → Positions
  164. implicit val RefTreeTag: ClassTag[RefTree]

    A tag that preserves the identity of the RefTree abstract type from erasure.

    A tag that preserves the identity of the RefTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  165. object ReferenceToBoxed extends internal.SymbolTable.ReferenceToBoxedExtractor with Serializable

    The constructor/extractor for ReferenceToBoxed instances.

    The constructor/extractor for ReferenceToBoxed instances.

    Definition Classes
    Trees → Trees
  166. implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]

    A tag that preserves the identity of the ReferenceToBoxed abstract type from erasure.

    A tag that preserves the identity of the ReferenceToBoxed abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  167. object RefinedType extends internal.SymbolTable.RefinedTypeExtractor with Serializable

    The constructor/extractor for RefinedType instances.

    The constructor/extractor for RefinedType instances.

    Definition Classes
    Types → Types
  168. implicit val RefinedTypeTag: ClassTag[RefinedType]

    A tag that preserves the identity of the RefinedType abstract type from erasure.

    A tag that preserves the identity of the RefinedType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  169. object Return extends internal.SymbolTable.ReturnExtractor with Serializable

    The constructor/extractor for Return instances.

    The constructor/extractor for Return instances.

    Definition Classes
    Trees → Trees
  170. implicit val ReturnTag: ClassTag[Return]

    A tag that preserves the identity of the Return abstract type from erasure.

    A tag that preserves the identity of the Return abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  171. object Scope

    Definition Classes
    Scopes
  172. implicit val ScopeTag: ClassTag[Scope]

    A tag that preserves the identity of the Scope abstract type from erasure.

    A tag that preserves the identity of the Scope abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Scopes → Scopes
  173. def Select(qualifier: Tree, sym: Symbol): Select

    A factory method for Select nodes.

    A factory method for Select nodes.

    Definition Classes
    Trees → Trees
  174. 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
  175. object Select extends internal.SymbolTable.SelectExtractor with Serializable

    The constructor/extractor for Select instances.

    The constructor/extractor for Select instances.

    Definition Classes
    Trees → Trees
  176. object SelectFromTypeTree extends internal.SymbolTable.SelectFromTypeTreeExtractor with Serializable

    The constructor/extractor for SelectFromTypeTree instances.

    The constructor/extractor for SelectFromTypeTree instances.

    Definition Classes
    Trees → Trees
  177. implicit val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]

    A tag that preserves the identity of the SelectFromTypeTree abstract type from erasure.

    A tag that preserves the identity of the SelectFromTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  178. implicit val SelectTag: ClassTag[Select]

    A tag that preserves the identity of the Select abstract type from erasure.

    A tag that preserves the identity of the Select abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  179. final val ShortTag: Int(4)

    Definition Classes
    Constants
  180. object SingleType extends internal.SymbolTable.SingleTypeExtractor with Serializable

    The constructor/extractor for SingleType instances.

    The constructor/extractor for SingleType instances.

    Definition Classes
    Types → Types
  181. implicit val SingleTypeTag: ClassTag[SingleType]

    A tag that preserves the identity of the SingleType abstract type from erasure.

    A tag that preserves the identity of the SingleType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  182. implicit val SingletonTypeTag: ClassTag[SingletonType]

    A tag that preserves the identity of the SingletonType abstract type from erasure.

    A tag that preserves the identity of the SingletonType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  183. object SingletonTypeTree extends internal.SymbolTable.SingletonTypeTreeExtractor with Serializable

    The constructor/extractor for SingletonTypeTree instances.

    The constructor/extractor for SingletonTypeTree instances.

    Definition Classes
    Trees → Trees
  184. implicit val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]

    A tag that preserves the identity of the SingletonTypeTree abstract type from erasure.

    A tag that preserves the identity of the SingletonTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  185. object Star extends internal.SymbolTable.StarExtractor with Serializable

    The constructor/extractor for Star instances.

    The constructor/extractor for Star instances.

    Definition Classes
    Trees → Trees
  186. implicit val StarTag: ClassTag[Star]

    A tag that preserves the identity of the Star abstract type from erasure.

    A tag that preserves the identity of the Star abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  187. implicit val StringContextStripMarginOps: (StringContext) ⇒ StringContextStripMarginOps

    Adds the sm String interpolator to a scala.StringContext.

    Adds the sm String interpolator to a scala.StringContext.

    Definition Classes
    SymbolTable
  188. final val StringTag: Int(10)

    Definition Classes
    Constants
  189. object StripAnnotationsMap extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  190. def Super(sym: Symbol, mix: TypeName): Tree

    A factory method for Super nodes.

    A factory method for Super nodes.

    Definition Classes
    Trees → Trees
  191. object Super extends internal.SymbolTable.SuperExtractor with Serializable

    The constructor/extractor for Super instances.

    The constructor/extractor for Super instances.

    Definition Classes
    Trees → Trees
  192. implicit val SuperTag: ClassTag[Super]

    A tag that preserves the identity of the Super abstract type from erasure.

    A tag that preserves the identity of the Super abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  193. object SuperType extends internal.SymbolTable.SuperTypeExtractor with Serializable

    The constructor/extractor for SuperType instances.

    The constructor/extractor for SuperType instances.

    Definition Classes
    Types → Types
  194. implicit val SuperTypeTag: ClassTag[SuperType]

    A tag that preserves the identity of the SuperType abstract type from erasure.

    A tag that preserves the identity of the SuperType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  195. object SuppressMacroExpansionAttachment extends Product with Serializable

    When present, suppresses macro expansion for the host.

    When present, suppresses macro expansion for the host. This is occasionally necessary, e.g. to prohibit eta-expansion of macros.

    Does not affect expandability of child nodes, there's context.withMacrosDisabled for that (but think thrice before using that API - see the discussion at https://github.com/scala/scala/pull/1639).

    Definition Classes
    StdAttachments
  196. implicit val SymTreeTag: ClassTag[SymTree]

    A tag that preserves the identity of the SymTree abstract type from erasure.

    A tag that preserves the identity of the SymTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  197. implicit val SymbolTag: ClassTag[Symbol]

    A tag that preserves the identity of the Symbol abstract type from erasure.

    A tag that preserves the identity of the Symbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  198. object Template extends internal.SymbolTable.TemplateExtractor with Serializable

    The constructor/extractor for Template instances.

    The constructor/extractor for Template instances.

    Definition Classes
    Trees → Trees
  199. implicit val TemplateTag: ClassTag[Template]

    A tag that preserves the identity of the Template abstract type from erasure.

    A tag that preserves the identity of the Template abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  200. implicit def TermNameOps(name: TermName): NameOps[TermName]

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

    A tag that preserves the identity of the TermName abstract type from erasure.

    A tag that preserves the identity of the TermName abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Names → Names
  202. implicit val TermSymbolTag: ClassTag[TermSymbol]

    A tag that preserves the identity of the TermSymbol abstract type from erasure.

    A tag that preserves the identity of the TermSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  203. implicit val TermTreeTag: ClassTag[TermTree]

    A tag that preserves the identity of the TermTree abstract type from erasure.

    A tag that preserves the identity of the TermTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  204. def This(sym: Symbol): Tree

    A factory method for This nodes.

    A factory method for This nodes.

    Definition Classes
    Trees → Trees
  205. object This extends internal.SymbolTable.ThisExtractor with Serializable

    The constructor/extractor for This instances.

    The constructor/extractor for This instances.

    Definition Classes
    Trees → Trees
  206. implicit val ThisTag: ClassTag[This]

    A tag that preserves the identity of the This abstract type from erasure.

    A tag that preserves the identity of the This abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  207. object ThisType extends internal.SymbolTable.ThisTypeExtractor with Serializable

    The constructor/extractor for ThisType instances.

    The constructor/extractor for ThisType instances.

    Definition Classes
    Types → Types
  208. implicit val ThisTypeTag: ClassTag[ThisType]

    A tag that preserves the identity of the ThisType abstract type from erasure.

    A tag that preserves the identity of the ThisType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  209. def Throw(tpe: Type, args: Tree*): Throw

    A factory method for Throw nodes.

    A factory method for Throw nodes.

    Definition Classes
    Trees → Trees
  210. object Throw extends internal.SymbolTable.ThrowExtractor with Serializable

    The constructor/extractor for Throw instances.

    The constructor/extractor for Throw instances.

    Definition Classes
    Trees → Trees
  211. implicit val ThrowTag: ClassTag[Throw]

    A tag that preserves the identity of the Throw abstract type from erasure.

    A tag that preserves the identity of the Throw abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  212. object ThrownException

    Extracts symbol of thrown exception from AnnotationInfo.

    Extracts symbol of thrown exception from AnnotationInfo.

    Supports both “old-style” @throws(classOf[Exception]) as well as “new-stye” @throws[Exception]("cause") annotations.

    Definition Classes
    AnnotationInfos
  213. implicit val TreeTag: ClassTag[Tree]

    A tag that preserves the identity of the Tree abstract type from erasure.

    A tag that preserves the identity of the Tree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  214. def Try(body: Tree, cases: (Tree, Tree)*): Try

    A factory method for Try nodes.

    A factory method for Try nodes.

    Definition Classes
    Trees → Trees
  215. object Try extends internal.SymbolTable.TryExtractor with Serializable

    The constructor/extractor for Try instances.

    The constructor/extractor for Try instances.

    Definition Classes
    Trees → Trees
  216. implicit val TryTag: ClassTag[Try]

    A tag that preserves the identity of the Try abstract type from erasure.

    A tag that preserves the identity of the Try abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  217. implicit val TypTreeTag: ClassTag[TypTree]

    A tag that preserves the identity of the TypTree abstract type from erasure.

    A tag that preserves the identity of the TypTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  218. object TypeApply extends internal.SymbolTable.TypeApplyExtractor with Serializable

    The constructor/extractor for TypeApply instances.

    The constructor/extractor for TypeApply instances.

    Definition Classes
    Trees → Trees
  219. implicit val TypeApplyTag: ClassTag[TypeApply]

    A tag that preserves the identity of the TypeApply abstract type from erasure.

    A tag that preserves the identity of the TypeApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  220. object TypeBounds extends internal.SymbolTable.TypeBoundsExtractor with Serializable

    The constructor/extractor for TypeBounds instances.

    The constructor/extractor for TypeBounds instances.

    Definition Classes
    Types → Types
  221. implicit val TypeBoundsTag: ClassTag[TypeBounds]

    A tag that preserves the identity of the TypeBounds abstract type from erasure.

    A tag that preserves the identity of the TypeBounds abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  222. object TypeBoundsTree extends internal.SymbolTable.TypeBoundsTreeExtractor with Serializable

    The constructor/extractor for TypeBoundsTree instances.

    The constructor/extractor for TypeBoundsTree instances.

    Definition Classes
    Trees → Trees
  223. implicit val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]

    A tag that preserves the identity of the TypeBoundsTree abstract type from erasure.

    A tag that preserves the identity of the TypeBoundsTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  224. def TypeDef(sym: Symbol): TypeDef

    A TypeDef node which defines abstract type or type parameter for given sym

    A TypeDef node which defines abstract type or type parameter for given sym

    Definition Classes
    Trees → Trees
  225. def TypeDef(sym: Symbol, rhs: Tree): TypeDef

    A TypeDef node which defines given sym with given tight hand side rhs.

    A TypeDef node which defines given sym with given tight hand side rhs.

    Definition Classes
    Trees → Trees
  226. object TypeDef extends internal.SymbolTable.TypeDefExtractor with Serializable

    The constructor/extractor for TypeDef instances.

    The constructor/extractor for TypeDef instances.

    Definition Classes
    Trees → Trees
  227. implicit val TypeDefTag: ClassTag[TypeDef]

    A tag that preserves the identity of the TypeDef abstract type from erasure.

    A tag that preserves the identity of the TypeDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  228. implicit def TypeNameOps(name: TypeName): NameOps[TypeName]

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

    A tag that preserves the identity of the TypeName abstract type from erasure.

    A tag that preserves the identity of the TypeName abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Names → Names
  230. object TypeRef extends internal.SymbolTable.TypeRefExtractor with Serializable

    The constructor/extractor for TypeRef instances.

    The constructor/extractor for TypeRef instances.

    Definition Classes
    Types → Types
  231. implicit val TypeRefTag: ClassTag[TypeRef]

    A tag that preserves the identity of the TypeRef abstract type from erasure.

    A tag that preserves the identity of the TypeRef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  232. implicit val TypeSymbolTag: ClassTag[TypeSymbol]

    A tag that preserves the identity of the TypeSymbol abstract type from erasure.

    A tag that preserves the identity of the TypeSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols → Symbols
  233. object TypeTag extends Serializable

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

  234. implicit val TypeTagg: ClassTag[Type]

    A tag that preserves the identity of the Type abstract type from erasure.

    A tag that preserves the identity of the Type abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types → Types
  235. def TypeTree(tp: Type): TypeTree

    A factory method for TypeTree nodes.

    A factory method for TypeTree nodes.

    Definition Classes
    Trees → Trees
  236. object TypeTree extends internal.SymbolTable.TypeTreeExtractor with Serializable

    The constructor/extractor for TypeTree instances.

    The constructor/extractor for TypeTree instances.

    Definition Classes
    Trees → Trees
  237. implicit val TypeTreeTag: ClassTag[TypeTree]

    A tag that preserves the identity of the TypeTree abstract type from erasure.

    A tag that preserves the identity of the TypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  238. object TypeVar extends Serializable

    Definition Classes
    Types
  239. object Typed extends internal.SymbolTable.TypedExtractor with Serializable

    The constructor/extractor for Typed instances.

    The constructor/extractor for Typed instances.

    Definition Classes
    Trees → Trees
  240. implicit val TypedTag: ClassTag[Typed]

    A tag that preserves the identity of the Typed abstract type from erasure.

    A tag that preserves the identity of the Typed abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  241. object UnApply extends internal.SymbolTable.UnApplyExtractor with Serializable

    The constructor/extractor for UnApply instances.

    The constructor/extractor for UnApply instances.

    Definition Classes
    Trees → Trees
  242. implicit val UnApplyTag: ClassTag[UnApply]

    A tag that preserves the identity of the UnApply abstract type from erasure.

    A tag that preserves the identity of the UnApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  243. final val UnitTag: Int(1)

    Definition Classes
    Constants
  244. object UnmappableAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable

    Definition Classes
    AnnotationInfos
  245. object UnmappableAnnotation extends internal.SymbolTable.CompleteAnnotationInfo

    Definition Classes
    AnnotationInfos
  246. object UnmappableTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with Product with Serializable

    Definition Classes
    Types
  247. def ValDef(sym: Symbol): ValDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  248. def ValDef(sym: Symbol, rhs: Tree): ValDef

    A factory method for ValDef nodes.

    A factory method for ValDef nodes.

    Definition Classes
    Trees → Trees
  249. object ValDef extends internal.SymbolTable.ValDefExtractor with Serializable

    The constructor/extractor for ValDef instances.

    The constructor/extractor for ValDef instances.

    Definition Classes
    Trees → Trees
  250. implicit val ValDefTag: ClassTag[ValDef]

    A tag that preserves the identity of the ValDef abstract type from erasure.

    A tag that preserves the identity of the ValDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  251. implicit val ValOrDefDefTag: ClassTag[ValOrDefDef]

    A tag that preserves the identity of the ValOrDefDef abstract type from erasure.

    A tag that preserves the identity of the ValOrDefDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees → Trees
  252. object WeakTypeTag extends Serializable

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

  253. object WildcardType extends internal.SymbolTable.Type 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
  254. def abort(msg: String): Nothing

    Definition Classes
    SymbolTable
  255. def abstractTypesToBounds(tp: Type): Type

    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
    Types
  256. def adaptAnnotations(tree: Tree, mode: Int, pt: Type): Tree

    Definition Classes
    AnnotationCheckers
  257. def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds]

    Definition Classes
    AnnotationCheckers
    See also

    AnnotationChecker.adaptBoundsToAnnotations

  258. object adaptToNewRunMap extends internal.SymbolTable.TypeMap

    Definition Classes
    Types
  259. def adaptTypeOfReturn(tree: Tree, pt: Type, default: ⇒ Type): Type

    Definition Classes
    AnnotationCheckers
  260. def addAnnotationChecker(checker: AnnotationChecker): Unit

    Register an annotation checker.

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

    Definition Classes
    AnnotationCheckers
  261. def addAnnotations(tree: Tree, tpe: Type): Type

    Definition Classes
    AnnotationCheckers
  262. implicit def addFlagOps(left: FlagSet): FlagOps

    The API of FlagSet instances.

    The API of FlagSet instances.

    Definition Classes
    FlagSets → FlagSets
  263. def addMember(thistp: Type, tp: Type, sym: Symbol, depth: Int): 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
  264. def addMember(thistp: Type, tp: Type, sym: Symbol): Unit

    Definition Classes
    Types
  265. def addSerializable(ps: Type*): List[Type]

    Definition Classes
    Types
  266. final def afterCurrentPhase[T](op: ⇒ T): T

    Definition Classes
    SymbolTable
    Annotations
    @inline()
  267. final def afterPhase[T](ph: Phase)(op: ⇒ T): T

    Definition Classes
    SymbolTable
    Annotations
    @inline()
  268. def annotatedType(annots: List[AnnotationInfo], underlying: Type, selfsym: Symbol = NoSymbol): Type

    Creator for AnnotatedTypes.

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

    Definition Classes
    Types
  269. def annotationsConform(tp1: Type, tp2: Type): Boolean

    Definition Classes
    AnnotationCheckers
    See also

    AnnotationChecker.annotationsConform

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

    Definition Classes
    AnnotationCheckers
    See also

    AnnotationChecker.annotationsGlb

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

    Definition Classes
    AnnotationCheckers
    See also

    AnnotationChecker.annotationsLub

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

    Very convenient.

    Very convenient.

    Definition Classes
    Types
  273. def appliedType(tycon: Type, args: List[Type]): Type

    A creator for type applications

    A creator for type applications

    Definition Classes
    Types → Types
  274. def appliedTypeAsUpperBounds(tycon: Type, args: List[Type]): Type

    A creator for existential types where the type arguments, rather than being applied directly, are interpreted as the upper bounds of unknown types.

    A creator for existential types where the type arguments, rather than being applied directly, are interpreted as the upper bounds of unknown types. For instance if the type argument list given is List(AnyRefClass), the resulting type would be e.g. Set[_ <: AnyRef] rather than Set[AnyRef] .

    Definition Classes
    Types
  275. 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
  276. final def asInstanceOf[T0]: T0

    Cast the receiver object to be of type T0.

    Cast the receiver object to be of type T0.

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

    returns

    the receiver object.

    Definition Classes
    Any
    Exceptions thrown
    ClassCastException

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

  277. 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( level = elidable.WARNING )
  278. final def atPhase[T](ph: Phase)(op: ⇒ T): T

    Perform given operation at given phase.

    Perform given operation at given phase.

    Definition Classes
    SymbolTable
    Annotations
    @inline()
  279. final def atPhaseNotLaterThan[T](target: Phase)(op: ⇒ T): T

    Definition Classes
    SymbolTable
    Annotations
    @inline()
  280. final def atPhaseStack: List[Phase]

    Definition Classes
    SymbolTable
  281. def atPhaseStackMessage: String

    Definition Classes
    SymbolTable
  282. def atPos[T <: Tree](pos: Position)(tree: T): T

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

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

    Definition Classes
    Positions → Positions
  283. 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
  284. def baseTypeOfNonClassTypeRef(tpe: NonClassTypeRef, clazz: Symbol): Type

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  285. 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
  286. final def beforePhase[T](ph: Phase)(op: ⇒ T): T

    Since when it is to be "at" a phase is inherently ambiguous, a couple unambiguously named methods.

    Since when it is to be "at" a phase is inherently ambiguous, a couple unambiguously named methods.

    Definition Classes
    SymbolTable
    Annotations
    @inline()
  287. final def beforePrevPhase[T](op: ⇒ T): T

    Definition Classes
    SymbolTable
    Annotations
    @inline()
  288. def beginsWithTypeVarOrIsRefined(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
  289. object binarynme

    Java binary names, like scala/runtime/Nothing$.

    Java binary names, like scala/runtime/Nothing$.

    Definition Classes
    StdNames
  290. val build: BuildApi

    Definition Classes
    BuildUtils
  291. def canAdaptAnnotations(tree: Tree, mode: Int, pt: Type): Boolean

    Definition Classes
    AnnotationCheckers
  292. def captureVariable(vble: Symbol): Unit

    Mark a variable as captured; i.

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

    Definition Classes
    CapturedVariables
  293. 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
  294. 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
  295. 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
  296. var chrs: Array[Char]

    Memory to store all names sequentially.

    Memory to store all names sequentially.

    Definition Classes
    Names
  297. def clone(): AnyRef

    Create a copy of the receiver object.

    Create a copy of the receiver object.

    The default implementation of the clone method is platform dependent.

    returns

    a copy of the receiver object.

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

    not specified by SLS as a member of AnyRef

  298. def cloneSymbols(syms: List[Symbol]): List[Symbol]

    Convenience functions which derive symbols by cloning.

    Convenience functions which derive symbols by cloning.

    Definition Classes
    Symbols
  299. 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
  300. def cloneSymbolsAtOwner(syms: List[Symbol], owner: Symbol): List[Symbol]

    Definition Classes
    Symbols
  301. def cloneSymbolsAtOwnerAndModify(syms: List[Symbol], owner: Symbol, infoFn: (Type) ⇒ Type): List[Symbol]

    Definition Classes
    Symbols
  302. 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
  303. final def collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) ⇒ Boolean): Map[A, B]

    Definition Classes
    Collections
  304. def commonOwnerMap: CommonOwnerMap

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  305. final def compareLengths(xs1: List[_], xs2: List[_]): Int

    Definition Classes
    Types
    Annotations
    @tailrec()
  306. def compoundBaseTypeSeq(tp: Type): BaseTypeSeq

    Create the base type sequence of a compound type wuth given tp.

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

    Definition Classes
    BaseTypeSeqs
  307. def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol

    Definition Classes
    SynchronizedSymbols → Symbols
  308. def containsExistential(tpe: Type): Boolean

    Definition Classes
    Types
  309. def copyClassDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, impl: Template = null): ClassDef

    Definition Classes
    Trees
  310. 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
  311. def copyMethodType(tp: Type, params: List[Symbol], restpe: Type): Type

    Create a new MethodType of the same class as tp, i.

    Create a new MethodType of the same class as tp, i.e. keep JavaMethodType

    Definition Classes
    Types
  312. def copyRefinedType(original: RefinedType, parents: List[Type], decls: Scope): Type

    Definition Classes
    Types
  313. def copyTypeRef(tp: Type, pre: Type, sym: Symbol, args: List[Type]): Type

    Definition Classes
    Types
  314. def copyValDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tpt: Tree = null, rhs: Tree = null): ValDef

    Definition Classes
    Trees
  315. 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()
  316. def createClassModule(owner: Symbol, name: TypeName, completer: (Symbol, Symbol) ⇒ 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
  317. 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
  318. def createFromClonedSymbolsAtOwner[T](syms: List[Symbol], owner: Symbol, tpe: Type)(creator: (List[Symbol], Type) ⇒ T): T

    Definition Classes
    Symbols
  319. final def currentPeriod: Period

    The current period.

    The current period.

    Definition Classes
    SymbolTable
  320. val currentRunId: Int

    The current compiler run identifier.

    The current compiler run identifier.

    Definition Classes
    ReflectSetup → SymbolTable
  321. def debugInfo(msg: ⇒ String): Unit

    Definition Classes
    SymbolTable
  322. 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
  323. def debugString(tp: Type): String

    Definition Classes
    TypeDebugging
  324. def debuglog(msg: ⇒ String): Unit

    Override with final implementation for inlining.

    Override with final implementation for inlining.

    Definition Classes
    SymbolTable
  325. def debugwarn(msg: ⇒ String): Unit

    Definition Classes
    SymbolTable
  326. def decodedSymName(tree: Tree, name: Name): String

    Definition Classes
    Printers
  327. def defineBaseClassesOfCompoundType(tpe: CompoundType): Unit

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  328. def defineBaseTypeSeqOfCompoundType(tpe: CompoundType): Unit

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  329. def defineBaseTypeSeqOfTypeRef(tpe: TypeRef): Unit

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  330. def defineParentsOfTypeRef(tpe: TypeRef): Unit

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  331. def defineUnderlyingOfSingleType(tpe: SingleType): Unit

    Attributes
    protected
    Definition Classes
    SynchronizedTypes → Types
  332. 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
  333. def deriveCaseDef(cdef: Tree)(applyToBody: (Tree) ⇒ Tree): CaseDef

    Definition Classes
    Trees
  334. def deriveClassDef(cdef: Tree)(applyToImpl: (Template) ⇒ Template): ClassDef

    Definition Classes
    Trees
  335. def deriveDefDef(ddef: Tree)(applyToRhs: (Tree) ⇒ Tree): DefDef

    Definition Classes
    Trees
  336. 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 SI-7782)

    Definition Classes
    ExistentialsAndSkolems
  337. def deriveLabelDef(ldef: Tree)(applyToRhs: (Tree) ⇒ Tree): LabelDef

    Definition Classes
    Trees
  338. def deriveModuleDef(mdef: Tree)(applyToImpl: (Template) ⇒ Template): ModuleDef

    Definition Classes
    Trees
  339. 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
  340. def deriveTemplate(templ: Tree)(applyToBody: (List[Tree]) ⇒ List[Tree]): Template

    Definition Classes
    Trees
  341. 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-subsituted type

    Definition Classes
    Symbols
  342. 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
  343. def deriveValDef(vdef: Tree)(applyToRhs: (Tree) ⇒ Tree): ValDef

    Definition Classes
    Trees
  344. def differentOrNone(tp1: Type, tp2: Type): Type

    Definition Classes
    Types
  345. final def distinctBy[A, B](xs: List[A])(f: (A) ⇒ B): List[A]

    Definition Classes
    Collections
  346. object dropAllRefinements extends internal.SymbolTable.TypeMap

    Substitutes the empty scope for any non-empty decls in the type.

    Substitutes the empty scope for any non-empty decls in the type.

    Definition Classes
    Types
  347. object dropRepeatedParamType 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
    Types
  348. 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
    Types
  349. def duplicateAndKeepPositions(tree: Tree): Tree

    Definition Classes
    Trees
  350. def elimAnonymousClass(t: Type): Type

    Definition Classes
    Types
  351. def elimRefinement(t: Type): Type

    Definition Classes
    Types
  352. val emptySymbolArray: Array[Symbol]

    Definition Classes
    Symbols
  353. object emptyValDef extends internal.SymbolTable.ValDef

    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
  354. val enableTypeVarExperimentals: Boolean

    Attributes
    protected
    Definition Classes
    Types
  355. def encode(str: String): TermName

    Definition Classes
    StdNames
  356. def ensureNonOverlapping(tree: Tree, others: List[Tree], focus: Boolean): Unit

    Definition Classes
    Positions
  357. 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
  358. def ensuring(cond: (JavaUniverse) ⇒ Boolean, msg: ⇒ Any): JavaUniverse

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

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

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

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

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

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

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

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

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

    returns

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

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

    The equality method for reference types.

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

    See also equals in scala.Any.

    returns

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

    Definition Classes
    AnyRef → Any
  364. def erasure: Erasure { val global: JavaUniverse.this.type }

    Definition Classes
    Transforms
  365. def etaExpandKeepsStar: Boolean

    Attributes
    protected
    Definition Classes
    Types
  366. def existentialAbstraction(tparams: List[Symbol], tpe0: Type): 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 → Types
  367. final def existentialTransform[T](rawSyms: List[Symbol], tp: Type, rawOwner: Option[Symbol] = None)(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
  368. def existentialsInType(tpe: Type): List[Symbol]

    Definition Classes
    Types
  369. final def exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean

    Definition Classes
    Collections
  370. final def exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean

    Definition Classes
    Collections
  371. 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
    SynchronizedTypes → Types
  372. 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
  373. 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
  374. def finalize(): Unit

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

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

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

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

    not specified by SLS as a member of AnyRef

  375. final def findOrElse[A](xs: TraversableOnce[A])(p: (A) ⇒ Boolean)(orElse: ⇒ A): A

    Definition Classes
    Collections
  376. def findRecursiveBounds(ts: List[Type]): List[(Symbol, Symbol)]

    From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.

    From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.)

    returns

    List of symbol pairs holding the recursive type parameter and the parameter which references it.

    Definition Classes
    Types
  377. final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[B]]): List[B]

    Definition Classes
    Collections
  378. final def flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ List[C]): List[C]

    Definition Classes
    Collections
  379. final def flattensToEmpty(xss: Seq[Seq[_]]): Boolean

    Definition Classes
    Collections
    Annotations
    @tailrec()
  380. def forInteractive: Boolean

    Definition Classes
    JavaUniverse → Required
  381. def forMSIL: Boolean

    Are we compiling for .

    Are we compiling for .NET?

    Definition Classes
    SymbolTable
  382. def forScaladoc: Boolean

    Definition Classes
    JavaUniverse → Required
  383. final def forall2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean

    Definition Classes
    Collections
  384. final def forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean

    Definition Classes
    Collections
  385. final def foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Unit): Unit

    Definition Classes
    Collections
  386. final def foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Unit): Unit

    Definition Classes
    Collections
  387. final def foreachWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ Unit): Unit

    Definition Classes
    Collections
  388. def formatted(fmtstr: String): String

    Returns string formatted according to given format string.

    Returns string formatted according to given format string. Format strings are as for String.format (@see java.lang.String.format).

    Implicit information
    This member is added by an implicit conversion from JavaUniverse to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  389. def freshExistentialName(suffix: String): TypeName

    Attributes
    protected
    Definition Classes
    SynchronizedSymbols → Symbols
  390. def fromDeBruijn(owner: Symbol): TypeMap

    Definition Classes
    Types
  391. object fulltpnme extends internal.SymbolTable.TypeNames

    For fully qualified type names.

    For fully qualified type names.

    Definition Classes
    StdNames
  392. val gen: TreeGen { val global: JavaUniverse.this.type }

    Definition Classes
    SymbolTable
  393. def genPolyType(params: List[Symbol], tpe: Type): Type

    Definition Classes
    Types
  394. final def getClass(): Class[_]

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

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

    The nature of the representation is platform dependent.

    returns

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

    Definition Classes
    AnyRef → Any
    Note

    not specified by SLS as a member of AnyRef

  395. 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
    SynchronizedTypes → Types → Types
  396. def glbNorm(ts: List[Type], depth: Int): 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
    Types
  397. def globalError(msg: String): Unit

    Definition Classes
    SymbolTable
  398. 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
    Types
  399. def hashCode(): Int

    The hashCode method for reference types.

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

    returns

    the hash code value for this object.

    Definition Classes
    AnyRef → Any
  400. var ids: Int

    Attributes
    protected
    Definition Classes
    Symbols
  401. def importPrivateWithinFromJavaFlags(sym: Symbol, jflags: Int): Symbol

    Definition Classes
    SymbolTable
  402. def info(msg: ⇒ String): Unit

    Definition Classes
    SymbolTable
  403. var infoTransformers: InfoTransformer

    The set of all installed infotransformers.

    The set of all installed infotransformers.

    Definition Classes
    SymbolTable
  404. def inheritsJavaVarArgsMethod(clazz: Symbol): Boolean

    Definition Classes
    Types
  405. def init(): Unit

    Definition Classes
    JavaMirrors
  406. def initClassModule(clazz: Symbol, module: Symbol, completer: LazyType): Unit

    Attributes
    protected
    Definition Classes
    SymbolLoaders
  407. def instantiatedBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): List[TypeBounds]

    Definition Classes
    Types
  408. 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 → Types
  409. 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 → Types
  410. val intersectionWitness: WeakHashMap[List[Type], WeakReference[Type]]

    A map from lists to compound types that have the given list as parents.

    A map from lists to compound types that have the given list as parents. This is used to avoid duplication in the computation of base type sequences and baseClasses. It makes use of the fact that these two operations depend only on the parents, not on the refinement.

    Definition Classes
    Types
  411. 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
  412. def isBoundedGeneric(tp: Type): Boolean

    Definition Classes
    Types
  413. 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: http://groups.google.com/group/scala-internals/browse_thread/thread/eabcf3d406dab8b2.

    Definition Classes
    SymbolTable → SymbolTable
  414. def isConstantType(tp: Type): Boolean

    Definition Classes
    Types
  415. def isDifferentType(tp1: Type, tp2: Type): Boolean

    Definition Classes
    SynchronizedTypes → Types
  416. def isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean

    Definition Classes
    Types
  417. def isErrorOrWildcard(tp: Type): Boolean

    Definition Classes
    Types
  418. def isHKSubType0(tp1: Type, tp2: Type, depth: Int): Boolean

    Definition Classes
    Types
  419. final def isInstanceOf[T0]: Boolean

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

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

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

    returns

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

    Definition Classes
    Any
  420. def isJavaVarargsAncestor(clazz: Symbol): Boolean

    Definition Classes
    Types
  421. def isMacroExpansionSuppressed(tree: Tree): Boolean

    Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

    Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

    Definition Classes
    StdAttachments
  422. def isNonRefinementClassType(tpe: Type): Boolean

    Definition Classes
    Types
  423. def isNonValueType(tp: Type): Boolean

    SLS 3.

    SLS 3.3, Non-Value Types Is the given type definitely a non-value type, as defined in SLS 3.3? The specification-enumerated non-value types are method types, polymorphic method types, and type constructors. Supplements to the specified set of non-value types include: types which wrap non-value symbols (packages abd statics), overloaded types. Varargs and by-name types T* and (=>T) are not designated non-value types because there is code which depends on using them as type arguments, but their precise status is unclear.

    Definition Classes
    Types
  424. def isNumericSubType(tp1: Type, tp2: Type): Boolean

    The isNumericValueType tests appear redundant, but without them test/continuations-neg/function3.

    The isNumericValueType tests appear redundant, but without them test/continuations-neg/function3.scala goes into an infinite loop. (Even if the calls are to typeSymbolDirect.)

    Definition Classes
    Types
  425. 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
  426. def isPossiblePrefix(clazz: Symbol): Boolean

    Might the given symbol be important when calculating the prefix of a type? When tp.

    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
    Types
  427. def isRaw(sym: Symbol, args: List[Type]): Boolean

    Definition Classes
    Types
  428. def isRawParameter(sym: Symbol): Boolean

    Definition Classes
    ExistentialsAndSkolems
  429. def isRawType(tp: Type): Boolean

    Is type tp a raw type?

    Is type tp a raw type?

    Definition Classes
    Types
  430. def isReferenceToAnyVal(t: Tree): Boolean

    Definition Classes
    Trees
  431. def isReferenceToPredef(t: Tree): Boolean

    Is the tree Predef, scala.

    Is the tree Predef, scala.Predef, or _root_.scala.Predef?

    Definition Classes
    Trees
  432. def isReferenceToScalaMember(t: Tree, Id: Name): Boolean

    Definition Classes
    Trees
  433. def isSameType(tp1: Type, tp2: Type): Boolean

    Do tp1 and tp2 denote equivalent types?

    Do tp1 and tp2 denote equivalent types?

    Definition Classes
    SynchronizedTypes → Types
  434. def isSameType2(tp1: Type, tp2: Type): Boolean

    Definition Classes
    Types
  435. 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