Value Members

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

   Definition Classes

   AnyRef → Any

2.  final def ##: Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  lazy val AmbiguousSearchFailure: SearchResult

   Definition Classes

   Implicits

5.  def Delay(expanded: Global.Tree): Delayed

   Definition Classes

   Macros

6.  lazy val DivergentSearchFailure: SearchResult

   Definition Classes

   Implicits

7.  val ImportType: Global.ImportType.type

   Definition Classes

   Contexts

8.  def MacroCantExpand210xMacrosError(internalMessage: String): Nothing

   Definition Classes

   ContextErrors

9.  def MacroCantExpandIncompatibleMacrosError(internalMessage: String): Nothing

   Definition Classes

   ContextErrors

10.  def NoImplicitFoundAnnotation(tree: Global.Tree, param: Global.Symbol): (Boolean, String)

    The implicit not found message from the annotation, and whether it's a supplement message or not.

    The implicit not found message from the annotation, and whether it's a supplement message or not.

    Definition Classes

    ContextErrors

11.  def NoImplicitFoundError(tree: Global.Tree, param: Global.Symbol)(implicit context: Context): Unit

    Definition Classes

    ContextErrors

12.  val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes

    Implicits

13.  lazy val SearchFailure: SearchResult

    Definition Classes

    Implicits

14.  def SearchedPrefixImplicitInfo(pre: Global.Type): ImplicitInfo

    Definition Classes

    Implicits

15.  def Skip(expanded: Global.Tree): Skipped

    Definition Classes

    Macros

16.  val _openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]

    Keeps track of macros in-flight.

    Keeps track of macros in-flight. See more informations in comments to openMacros in scala.reflect.macros.whitebox.Context.

    Definition Classes

    Macros

17.  def abstractVarMessage(sym: Global.Symbol): String

    An explanatory note to be added to error messages when there's a problem with abstract var defs

    An explanatory note to be added to error messages when there's a problem with abstract var defs

    Definition Classes

    TypeDiagnostics

18.  final def accessibleOwnerOrParentDefiningMember(member: Global.Symbol, parents: Iterator[Global.Symbol], context: Context): Option[Global.Symbol]

    The goal of this method is to find a class that is accessible (in bytecode) and can be used to select member.

    The goal of this method is to find a class that is accessible (in bytecode) and can be used to select member. - For constructors, it returns the member.owner. We can assume the class is accessible: if it wasn't, the typer would have rejected the program, as the class is referenced in source. - For Scala-defined members it also returns member.owner, all Scala-defined classes are public in bytecode. - For Java-defined members we prefer a direct parent over of the owner, even if the owner is accessible. This way the owner doesn't need to be added as a direct parent, see scala-dev#143.

    Definition Classes

    Erasure

19.  def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Global.Tree
    Definition Classes

    AnalyzerPlugins

    See also

    AnalyzerPlugin.adaptAnnotations

20.  def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Registers a new analyzer plugin

    Registers a new analyzer plugin

    Definition Classes

    AnalyzerPlugins

21.  def addDefaults(givenArgs: List[Global.Tree], qual: Option[Global.Tree], targs: List[Global.Tree], previousArgss: List[List[Global.Tree]], params: List[Global.Symbol], pos: reflect.internal.util.Position, context: Context): (List[Global.Tree], List[Global.Symbol])

    Extend the argument list givenArgs with default arguments.

    Extend the argument list givenArgs with default arguments. Defaults are added as named arguments calling the corresponding default getter.

    Example: given def foo(x: Int = 2, y: String = "def") foo(y = "lt") the argument list (y = "lt") is transformed to (y = "lt", x = foo$default$1())

    Definition Classes

    NamesDefaults

22.  def addMacroPlugin(plugin: MacroPlugin): Unit

    Registers a new macro plugin

    Registers a new macro plugin

    Definition Classes

    AnalyzerPlugins

23.  def addSyntheticMethods(templ: Global.Template, clazz0: Global.Symbol, context: Context): Global.Template

    Add the synthetic methods to case classes.

    Add the synthetic methods to case classes.

    Definition Classes

    SyntheticMethods

24.  final def afterOwnPhase[T](op: => T): T

    Definition Classes

    SubComponent

    Annotations

    @inline()

25.  def allArgsArePositional(a: Array[Int]): Boolean

    returns true if every element is equal to its index

    returns true if every element is equal to its index

    Definition Classes

    NamesDefaults

26.  def allViewsFrom(tp: Global.Type, context: Context, tpars: List[Global.Symbol]): List[(SearchResult, List[Global.TypeConstraint])]

    Find all views from type tp (in which tpars are free)

    Find all views from type tp (in which tpars are free)

    Note that the trees in the search results in the returned list share the same type variables. Ignore their constr field! The list of type constraints returned along with each tree specifies the constraints that must be met by the corresponding type parameter in tpars (for the returned implicit view to be valid).

    tp

    from-type for the implicit conversion

    context

    search implicits here

    tpars

    symbols that should be considered free type variables (implicit search should not try to solve them, just track their constraints)

    Definition Classes

    Implicits

27.  def alternatives(tree: Global.Tree): List[Global.Type]

    Definition Classes

    TypeDiagnostics

28.  def alternativesString(tree: Global.Tree): String

    Definition Classes

    TypeDiagnostics

29.  def ambiguousDefinitions(owner: Global.Symbol, other: Global.Symbol): Global.LookupAmbiguous

    Definition Classes

    Contexts

30.  def ambiguousDefnAndImport(owner: Global.Symbol, imp: ImportInfo): Global.LookupAmbiguous

    Definition Classes

    Contexts

31.  def ambiguousImports(imp1: ImportInfo, imp2: ImportInfo): Global.LookupAmbiguous

    Definition Classes

    Contexts

32.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

33.  def attachExpansion(sym: Global.Symbol, trees: List[Global.Tree]): Global.Symbol

    Definition Classes

    MacroAnnotationAttachments

34.  def attachSource(sym: Global.Symbol, tree: Global.Tree): Global.Symbol

    Definition Classes

    MacroAnnotationAttachments

35.  def attachedExpansion(sym: Global.Symbol): Option[List[Global.Tree]]

    Definition Classes

    MacroAnnotationAttachments

36.  def attachedSource(sym: Global.Symbol): Global.Tree

    Definition Classes

    MacroAnnotationAttachments

37.  def backupCompleter(sym: Global.Symbol): Global.Symbol

    Definition Classes

    MacroAnnotationAttachments

38.  final def beforeOwnPhase[T](op: => T): T

    Definition Classes

    SubComponent

    Annotations

    @inline()

39.  def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit

    Definition Classes

    Macros

40.  def bracket[A](params: List[A]): String

    Definition Classes

    SplainFormatting

41.  def breakInfix(types: List[Formatted]): TypeRepr

    Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal.

    Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal. If the expression's length is smaller than the threshold specified via plugin parameter, return a single line.

    Definition Classes

    SplainFormatting

42.  val breakInfixLength: Int

    Definition Classes

    SplainFormatting

43.  def builtinFoundReqMsg(found: Global.Type, req: Global.Type): String

    Definition Classes

    TypeDiagnostics

44.  def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Boolean
    Definition Classes

    AnalyzerPlugins

    See also

    AnalyzerPlugin.canAdaptAnnotations

45.  final def caseAccessorName(caseclazz: Global.Symbol, paramName: Global.TermName): Global.TermName

    Does not force the info of caseclazz

    Does not force the info of caseclazz

    Definition Classes

    SyntheticMethods

46.  def caseClassCopyMeth(cdef: Global.ClassDef): Option[Global.DefDef]

    Generates copy methods for case classes.

    Generates copy methods for case classes. Copy only has defaults on the first parameter list, as of scala/bug#5009.

    The parameter types of the copy method need to be exactly the same as the parameter types of the primary constructor. Just copying the TypeTree is not enough: a type C might refer to something else *inside* the class (i.e. as parameter type of copy) than *outside* the class (i.e. in the class parameter list).

    One such example is t0054.scala: class A { case class B(x: C) extends A { def copy(x: C = x) = ... } class C {} } (1) (2)

    The reference (1) to C is A.this.C. The reference (2) is B.this.C - not the same.

    This is fixed with a hack currently. Unapplies.caseClassCopyMeth, which creates the copy method, uses empty TypeTree() nodes for parameter types.

    In Namers.enterDefDef, the copy method gets a special type completer (enterCopyMethod). Before computing the body type of copy, the class parameter types are assigned the copy method parameters.

    This attachment class stores the copy method parameter ValDefs as an attachment in the ClassDef of the case class.

    Definition Classes

    Unapplies

47.  def caseModuleApplyMeth(cdef: Global.ClassDef): Global.DefDef

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes

    Unapplies

48.  def caseModuleDef(cdef: Global.ClassDef): Global.ModuleDef

    The module corresponding to a case class; overrides toString to show the module's name

    The module corresponding to a case class; overrides toString to show the module's name

    Definition Classes

    Unapplies

49.  def caseModuleUnapplyMeth(cdef: Global.ClassDef): Global.DefDef

    The unapply method corresponding to a case class

    The unapply method corresponding to a case class

    Definition Classes

    Unapplies

50.  def changesBaseClasses: Boolean

    Attributes

    protected

    Definition Classes

    InfoTransform

51.  def clearDelayed(): Unit

    Definition Classes

    Macros

52.  final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit

    Definition Classes

    SyntheticMethods

53.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.CloneNotSupportedException]) @native()

54.  def companionModuleDef(cdef: Global.ClassDef, parents: List[Global.Tree] = Nil, body: List[Global.Tree] = Nil): Global.ModuleDef

    Definition Classes

    Unapplies

55.  def companionSymbolOf(original: Global.Symbol, ctx: Context): Global.Symbol

    The companion class or companion module of original.

    The companion class or companion module of original. Calling .companionModule does not work for classes defined inside methods.

    !!! Then why don't we fix companionModule? Does the presence of these methods imply all the places in the compiler calling sym.companionModule are bugs waiting to be reported? If not, why not? When exactly do we need to call this method?

    Definition Classes

    Namers

56.  final def compilesToPureInterface(tpSym: Global.Symbol): Boolean

    Does this symbol compile to the underlying platform's notion of an interface, without requiring compiler magic before it can be instantiated?

    Does this symbol compile to the underlying platform's notion of an interface, without requiring compiler magic before it can be instantiated?

    More specifically, we're interested in whether LambdaMetaFactory can instantiate this type, assuming it has a single abstract method. In other words, if we were to mix this trait into a class, it should not result in any compiler-generated members having to be implemented in ("mixed in to") this class (except for the SAM).

    Thus, the type must erase to a java interface, either by virtue of being defined as one, or by being a trait that:

    • is static (explicitouter or lambdalift may add disqualifying members)
    • extends only other traits that compile to pure interfaces (except for Any)
    • has no val/var members

    TODO: can we speed this up using the INTERFACE flag, or set it correctly by construction?

    Definition Classes

    Erasure

57.  def ctorNames(tpe: Global.Type): List[String]

    Definition Classes

    SplainFormatting

58.  def dealias(tpe: Global.Type): Global.Type

    Definition Classes

    SplainFormatting

59.  def decideBreak(flat: FlatType, broken: => BrokenType): TypeRepr

    Definition Classes

    SplainFormatting

60.  def decodeWithKind(name: Global.Name, owner: Global.Symbol): String

    Definition Classes

    TypeDiagnostics

61.  val deconstMap: Global.TypeMap

    Definition Classes

    Erasure

62.  def decreaseMetalevel(tp: Global.Type): Global.Type

    Decreases metalevel of the type, i.e.

    Decreases metalevel of the type, i.e. transforms: * c.Expr[T] to T * Nothing to Nothing * Anything else to NoType

    Definition Classes

    Helpers

    See also

    Metalevels.scala for more information and examples about metalevels

63.  def deepestLevel(chain: List[ImplicitError]): Int

    Definition Classes

    SplainFormatting

64.  def defaultGetter(param: Global.Symbol, context: Context): Global.Symbol

    For a parameter with default argument, find the method symbol of the default getter.

    For a parameter with default argument, find the method symbol of the default getter.

    Definition Classes

    NamesDefaults

65.  def defaultMacroClassloader: ClassLoader

    Definition Classes

    MacroRuntimes

66.  final def definesMemberAfterErasure(cls: Global.Symbol, member: Global.Symbol): Boolean

    Check if a class defines a member after erasure.

    Check if a class defines a member after erasure. The phase travel is important for trait T extends AClass: after erasure (and in bytecode), T has supertype Object, not AClass.

    Definition Classes

    Erasure

67.  def directUnapplyMember(tp: Global.Type): Global.Symbol

    Returns unapply or unapplySeq if available, without further checks.

    Returns unapply or unapplySeq if available, without further checks.

    Definition Classes

    Unapplies

68.  def disambiguate(ss: List[String]): collection.immutable.List[String]

    Definition Classes

    TypeDiagnostics

69.  def enabled: Boolean

    Is this component enabled? Default is true.

    Is this component enabled? Default is true.

    Definition Classes

    SubComponent

70.  def enclosingMacroPosition: reflect.internal.util.Position

    Definition Classes

    Macros

71.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

72.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

73.  def erasedValueClassArg(tref: Global.TypeRef): Global.Type

    Definition Classes

    Erasure

74.  def erasure(sym: Global.Symbol): ErasureMap

    Definition Classes

    Erasure

75.  def etaExpand(tree: Global.Tree, owner: Global.Symbol)(implicit creator: FreshNameCreator): Global.Tree

    Expand partial method application p.f(es_1)...(es_n).

    Expand partial method application p.f(es_1)...(es_n). Does not support dependent method types (yet).

    We expand this to the following block, which evaluates the target of the application and its supplied arguments if needed (they are not stable), and then wraps a Function that abstracts over the missing arguments.

    {
      private synthetic val eta$f   = p.f   // if p is not stable
      ...
      private synthetic val eta$e_i = e_i   // if e_i is not stable
      ...
      (ps_1 => ... => ps_m => eta$f([es_1])...([es_m])(ps_1)...(ps_m))
    }

    This is called from typedEtaExpansion, which itself is called from

    • instantiateToMethodType (for a naked method reference), or
    • typedEta (when type checking a method value, m _).

    Definition Classes

    EtaExpansion

76.  final def exampleTuplePattern(names: List[Global.Name]): String

    [a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

    [a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

    Definition Classes

    TypeDiagnostics

77.  val excludedRootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]

    Definition Classes

    Contexts

78.  def existentialContext(tp: Global.Type): String

    Definition Classes

    TypeDiagnostics

79.  def explainAlias(tp: Global.Type): String

    Definition Classes

    TypeDiagnostics

80.  def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String

    Definition Classes

    TypeDiagnostics

81.  def explainVariance(found: Global.Type, req: Global.Type): String

    Look through the base types of the found type for any which might have been valid subtypes if given conformant type arguments.

    Look through the base types of the found type for any which might have been valid subtypes if given conformant type arguments. Examine those for situations where the type error would have been eliminated if the variance were different. In such cases, append an additional explanatory message.

    TODO: handle type aliases better.

    Definition Classes

    TypeDiagnostics

    Annotations

    @nowarn()

82.  def explicitlyUnit(tree: Global.Tree): Boolean

    Definition Classes

    StdAttachments

83.  def extractArgs(tpe: Global.Type): collection.immutable.List[Global.Type]

    Definition Classes

    SplainFormatting

84.  def factoryMeth(mods: Global.Modifiers, name: Global.TermName, cdef: Global.ClassDef): Global.DefDef

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes

    Unapplies

85.  final def falseIfNoInstance(body: => Boolean): Boolean

    Definition Classes

    Infer

    Annotations

    @inline()

86.  lazy val fastTrack: FastTrack[Global.erasure.this.type]

    Definition Classes

    Macros

87.  def finalOwners(tpe: Global.Type): Boolean

    Definition Classes

    TypeDiagnostics

88.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.Throwable])

89.  final def finishComputeParamAlias(): Unit

    Finish computation of param aliases after typechecking is completed

    Finish computation of param aliases after typechecking is completed

    Definition Classes

    Typers

90.  def flattenInfix(tpe: Infix): List[Formatted]

    Turn a nested infix type structure into a flat list

    Turn a nested infix type structure into a flat list

    ::[A, ::[B, C]]] => List(A, ::, B, ::, C)

    Definition Classes

    SplainFormatting

91.  final def forArgMode(fun: Global.Tree, mode: Mode): reflect.internal.Mode

    Definition Classes

    Typers

92.  def formalTypes(formals: List[Global.Type], numArgs: Int, removeByName: Boolean = true, removeRepeated: Boolean = true): List[Global.Type]

    The formal parameter types corresponding to formals.

    The formal parameter types corresponding to formals. If formals has a repeated last parameter, a list of (numArgs - numFormals + 1) copies of its type is appended to the other formals. By-name types are replaced with their underlying type.

    removeByName

    allows keeping ByName parameters. Used in NamesDefaults.

    removeRepeated

    allows keeping repeated parameter (if there's one argument). Used in NamesDefaults.

    Definition Classes

    Infer

93.  def formatAuxSimple(tpe: Global.Type): (List[String], String)

    Definition Classes

    SplainFormatting

94.  def formatDiff(left: Global.Type, right: Global.Type, top: Boolean): Formatted

    Definition Classes

    SplainFormatting

95.  val formatDiffCache: FormatCache[(Global.Type, Global.Type, Boolean), Formatted]

    Definition Classes

    SplainFormatting

96.  def formatDiffImpl(found: Global.Type, req: Global.Type, top: Boolean): Formatted

    Definition Classes

    SplainFormatting

97.  def formatDiffInfix(left: Global.Type, right: Global.Type, top: Boolean): Formatted

    Definition Classes

    SplainFormatting

98.  def formatDiffSimple(left: Global.Type, right: Global.Type): Formatted

    Definition Classes

    SplainFormatting

99.  def formatDiffSpecial(left: Global.Type, right: Global.Type, top: Boolean): Option[Formatted]

    Definition Classes

    SplainFormatting

100.  def formatFunction(args: List[String]): String

     Definition Classes

     SplainFormatting

101.  def formatImplicitChain(chain: List[ImplicitError]): List[String]

     Definition Classes

     SplainFormatting

102.  def formatImplicitChainFlat(chain: List[ImplicitError]): List[String]

     Definition Classes

     SplainFormatting

103.  def formatImplicitChainTreeCompact(chain: List[ImplicitError]): Option[List[String]]

     Definition Classes

     SplainFormatting

104.  def formatImplicitChainTreeFull(chain: List[ImplicitError]): List[String]

     Definition Classes

     SplainFormatting

105.  def formatImplicitError(param: Global.Symbol, errors: List[ImplicitError], annotationMsg: String): String

     Definition Classes

     SplainFormatting

106.  def formatIndentTree(chain: List[ImplicitError], baseIndent: Int): List[String]

     Definition Classes

     SplainFormatting

107.  def formatInfix[A](path: List[String], simple: String, left: A, right: A, top: Boolean)(rec: (A, Boolean) => Formatted): Formatted

     Definition Classes

     SplainFormatting

108.  def formatNestedImplicit(err: ImplicitError): (String, List[String], Int)

     Definition Classes

     SplainFormatting

109.  def formatNestedImplicits(errors: List[ImplicitError]): collection.immutable.List[String]

     Remove duplicates and special cases that should not be shown.

     Remove duplicates and special cases that should not be shown. In some cases, candidates are reported twice, once as Foo.f and once as f. ImplicitError.equals checks the simple names for identity, which is suboptimal, but works for 99% of cases. Special cases are handled in hideImpError

     Definition Classes

     SplainFormatting

110.  def formatNonConfBounds(err: NonconformantBounds): List[String]

     Definition Classes

     SplainFormatting

111.  def formatNormalSimple(tpe: Global.Type): (List[String], String)

     Definition Classes

     SplainFormatting

112.  def formatRefinement(sym: Global.Symbol): String

     Definition Classes

     SplainFormatting

113.  def formatSimpleType(tpe: Global.Type): (List[String], String)

     Definition Classes

     SplainFormatting

114.  def formatSpecial[A](tpe: Global.Type, simple: String, args: List[A], formattedArgs: => List[Formatted], top: Boolean)(rec: (A, Boolean) => Formatted): Option[Formatted]

     Definition Classes

     SplainFormatting

115.  def formatType(tpe: Global.Type, top: Boolean): Formatted

     Definition Classes

     SplainFormatting → SplainFormatters

116.  val formatTypeCache: FormatCache[(Global.Type, Boolean), Formatted]

     Definition Classes

     SplainFormatting

117.  def formatTypeImpl(tpe: Global.Type, top: Boolean): Formatted

     Definition Classes

     SplainFormatting

118.  def formatWithInfix[A](tpe: Global.Type, args: List[A], top: Boolean)(rec: (A, Boolean) => Formatted): Formatted

     Definition Classes

     SplainFormatting

119.  def formattedDiff(left: Formatted, right: Formatted): String

     Definition Classes

     SplainFormatting

120.  def foundReqMsg(found: Global.Type, req: Global.Type): String

     Definition Classes

     TypeDiagnostics

121.  def freshNameCreatorFor(context: Context): FreshNameCreator

     Definition Classes

     Typers

122.  def freshVar(tparam: Global.Symbol): Global.TypeVar

     A fresh type variable with given type parameter as origin.

     A fresh type variable with given type parameter as origin.

     Definition Classes

     Infer

123.  def fullSiteString(context: Context): String

     Definition Classes

     TypersTracking

124.  final def getClass(): Class[_ <: AnyRef]

     Definition Classes

     AnyRef → Any

     Annotations

     @native()

125.  val global: Global.this.type

     The global environment; overridden by instantiation in Global.

     The global environment; overridden by instantiation in Global.

     Definition Classes

     erasure → TypingTransformers → Analyzer → TreeDSL → Erasure → SubComponent

126.  def globalSettings: Settings

     Definition Classes

     Macros → Traces

127.  def hasAttachedExpansion(sym: Global.Symbol): Boolean

     Definition Classes

     MacroAnnotationAttachments

128.  def hasMacroExpansionAttachment(any: Any): Boolean

     Determines whether the target is either an original or a result of a macro expansion.

     Determines whether the target is either an original or a result of a macro expansion. The parameter is of type Any, because macros can expand both into trees and into annotations.

     Definition Classes

     StdAttachments

129.  val hasPendingMacroExpansions: Boolean

     Without any restrictions on macro expansion, macro applications will expand at will, and when type inference is involved, expansions will end up using yet uninferred type params.

     Without any restrictions on macro expansion, macro applications will expand at will, and when type inference is involved, expansions will end up using yet uninferred type params.

     For some macros this might be ok (thanks to TreeTypeSubstituter that replaces the occurrences of undetparams with their inferred values), but in general case this won't work. E.g. for reification simple substitution is not enough - we actually need to re-reify inferred types.

     Luckily, there exists a very simple way to fix the problem: delay macro expansion until everything is inferred. Here are the exact rules. Macro application gets delayed if any of its subtrees contain: 1) type vars (tpe.isInstanceOf[TypeVar]) // [Eugene] this check is disabled right now, because TypeVars seem to be created from undetparams anyways 2) undetparams (sym.isTypeParameter && !sym.isSkolem)

     Definition Classes

     Macros

130.  def hasSuperArgs(tree: Global.Tree): Boolean

     Determines whether the given tree has an associated SuperArgsAttachment.

     Determines whether the given tree has an associated SuperArgsAttachment.

     Definition Classes

     StdAttachments

131.  def hashCode(): Int

     SubComponents are added to a HashSet and two phases are the same if they have the same name.

     SubComponents are added to a HashSet and two phases are the same if they have the same name.

     Definition Classes

     SubComponent → AnyRef → Any

132.  def hideImpError(error: ImplicitError): Boolean

     Definition Classes

     SplainFormatting

133.  def implicitMessage(param: Global.Symbol, annotationMsg: String): List[String]

     Definition Classes

     SplainFormatting

134.  def increaseMetalevel(pre: Global.Type, tp: Global.Type): Global.Type

     Increases metalevel of the type, i.e.

     Increases metalevel of the type, i.e. transforms: * T to c.Expr[T]

     Definition Classes

     Helpers

     See also

     Metalevels.scala for more information and examples about metalevels

135.  def indent(lines: List[String], n: Int = 1, prefix: String = " "): collection.immutable.List[String]

     Definition Classes

     SplainFormatting

136.  def indentLine(line: String, n: Int = 1, prefix: String = " "): String

     Definition Classes

     SplainFormatting

137.  def indentTree(tree: List[(String, List[String], Int)], baseIndent: Int): List[String]

     Definition Classes

     SplainFormatting

138.  def inferImplicit(tree: Global.Tree, pt: Global.Type, isView: Boolean, context: Context, silent: Boolean, withMacrosDisabled: Boolean, pos: Global.Position, onError: (Global.Position, String) => Unit): Global.Tree

     A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

     A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

     Definition Classes

     Implicits

139.  def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean, pos: Global.Position): SearchResult

     Search for an implicit value.

     Search for an implicit value. Consider using one of the convenience methods above. This one has many boolean levers.

     See the comment on result at the end of class ImplicitSearch for more info how the search is conducted.

     tree

     The tree for which the implicit needs to be inserted. (the inference might instantiate some of the undetermined type parameters of that tree.

     pt

     The expected type of the implicit.

     reportAmbiguous

     Should ambiguous implicit errors be reported? False iff we search for a view to find out whether one type is coercible to another.

     isView

     We are looking for a view

     context

     The current context

     saveAmbiguousDivergent

     False if any divergent/ambiguous errors should be ignored after implicits search, true if they should be reported (used in further typechecking).

     pos

     Position that should be used for tracing and error reporting (useful when we infer synthetic stuff and pass EmptyTree in the tree argument) If it's set to NoPosition, then position-based services will use tree.pos

     returns

     A search result

     Definition Classes

     Implicits

140.  def inferImplicitByType(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult

     Definition Classes

     Implicits

141.  def inferImplicitByTypeSilent(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult

     Definition Classes

     Implicits

142.  def inferImplicitFor(pt: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean = true): SearchResult

     Definition Classes

     Implicits

143.  def inferImplicitView(from: Global.Type, to: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean, saveAmbiguousDivergent: Boolean): SearchResult

     Definition Classes

     Implicits

144.  val initial: Boolean

     True if this phase runs before all other phases.

     True if this phase runs before all other phases. Usually, parser.

     Definition Classes

     SubComponent

145.  def instantiateSamFromFunction(funTp: Global.Type, samTp: Global.Type, sam: Global.Symbol): Global.Type

     Definition Classes

     Infer

146.  val internal: Boolean

     True if this phase is not provided by a plug-in.

     True if this phase is not provided by a plug-in.

     Definition Classes

     SubComponent

147.  def intersectionDominator(parents: List[Global.Type]): Global.Type

     Definition Classes

     Erasure

148.  def isAux(tpe: Global.Type): Boolean

     Definition Classes

     SplainFormatting

149.  def isBlackbox(macroDef: Global.Symbol): Boolean

     Definition Classes

     Macros

150.  def isBlackbox(expandee: Global.Tree): Boolean

     Definition Classes

     Macros

151.  def isDynamicRewrite(tree: Global.Tree): Boolean

     Definition Classes

     StdAttachments

152.  def isExpanded(sym: Global.Symbol): Boolean

     Definition Classes

     MacroAnnotationAttachments

153.  final def isInstanceOf[T0]: Boolean

     Definition Classes

     Any

154.  final def isJvmAccessible(cls: Global.Symbol, context: Context): Boolean

     Definition Classes

     Erasure

155.  def isMacroExpansionSuppressed(tree: Global.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

156.  def isMacroImplRef(tree: Global.Tree): Boolean

     Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

     Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

     Definition Classes

     StdAttachments

157.  def isMaybeExpandee(sym: Global.Symbol): Boolean

     Definition Classes

     MacroAnnotationAttachments

158.  def isNamedArg(arg: Global.Tree): Boolean

     Definition Classes

     NamesDefaults

159.  def isNotExpandable(sym: Global.Symbol): Boolean

     Definition Classes

     MacroAnnotationAttachments

160.  def isRefined(tpe: Global.Type): Boolean

     Definition Classes

     SplainFormatting

161.  def isSymbolic(tpe: Global.Type): Boolean

     Definition Classes

     SplainFormatting

162.  def isWeak(sym: Global.Symbol): Boolean

     Definition Classes

     MacroAnnotationAttachments

163.  final def javaSig(sym0: Global.Symbol, info: Global.Type, markClassUsed: (Global.Symbol) => Unit): Option[String]

     The Java signature of type 'info', for symbol sym.

     The Java signature of type 'info', for symbol sym. The symbol is used to give the right return type for constructors.

     Definition Classes

     Erasure

164.  def keepsTypeParams: Boolean

     Definition Classes

     Erasure → InfoTransform

165.  val lastAccessCheckDetails: String

     Definition Classes

     Contexts

166.  val lastTreeToTyper: Global.Tree

     Definition Classes

     TypersTracking

167.  def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean

     Definition Classes

     TypeDiagnostics

168.  def linkExpandeeAndDesugared(expandee: Global.Tree, desugared: Global.Tree): Unit

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

     Definition Classes

     StdAttachments

169.  def linkExpandeeAndExpanded(expandee: Global.Tree, expanded: Any): Unit

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

     After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment. The expanded parameter is of type Any, because macros can expand both into trees and into annotations.

     Definition Classes

     StdAttachments

170.  final def linkedClassOfClassOf(original: Global.Symbol, ctx: Context): Global.Symbol

     A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.

     A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.

     Definition Classes

     Namers

171.  def loadMacroImplBinding(macroDef: Global.Symbol): Option[MacroImplBinding]

     Definition Classes

     Macros

172.  def macroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

     Definition Classes

     Macros

173.  def macroContext(typer: Typer, prefixTree: Global.Tree, expandeeTree: Global.Tree): MacroContext

     Definition Classes

     Macros

174.  val macroDebugLite: Boolean

     Definition Classes

     Traces

175.  val macroDebugVerbose: Boolean

     Definition Classes

     Traces

176.  def macroEngine: String

     Macro def -> macro impl bindings are serialized into a macroImpl annotation with synthetic content that carries the payload described in MacroImplBinding.

     Macro def -> macro impl bindings are serialized into a macroImpl annotation with synthetic content that carries the payload described in MacroImplBinding.

     For example, for a pair of macro definition and macro implementation: def impl(c: scala.reflect.macros.blackbox.Context): c.Expr[Unit] = ??? def foo: Unit = macro impl

     We will have the following annotation added on the macro definition foo:

     @scala.reflect.macros.internal.macroImpl(
       `macro`(
         "macroEngine" = <current macro engine>,
         "isBundle" = false,
         "isBlackbox" = true,
         "signature" = List(Other),
         "methodName" = "impl",
         "className" = "Macros$"))

     Definition Classes

     Macros

177.  def macroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

     Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

     Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

     Definition Classes

     Macros

     See also

     DefMacroExpander

178.  def macroExpandAll(typer: Typer, expandee: Global.Tree): Global.Tree

     Performs macro expansion on all subtrees of a given tree.

     Performs macro expansion on all subtrees of a given tree. Innermost macros are expanded first, outermost macros are expanded last. See the documentation for macroExpand for more information.

     Definition Classes

     Macros

179.  def macroExpandWithRuntime(typer: Typer, expandee: Global.Tree, runtime: MacroRuntime): MacroStatus

     Expands a macro when a runtime (i.e.

     Expands a macro when a runtime (i.e. the macro implementation) can be successfully loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

     Definition Classes

     Macros

180.  def macroExpandWithoutRuntime(typer: Typer, expandee: Global.Tree): MacroStatus

     Expands a macro when a runtime (i.e.

     Expands a macro when a runtime (i.e. the macro implementation) cannot be loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

     Definition Classes

     Macros

181.  def macroExpandee(tree: Global.Tree): Global.Tree

     Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

     Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

     Definition Classes

     StdAttachments

182.  def macroExpanderAttachment(tree: Global.Tree): MacroExpanderAttachment

     Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

     Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

     Definition Classes

     StdAttachments

183.  final def macroLogLite(msg: => Any): Unit

     Definition Classes

     Traces

     Annotations

     @inline()

184.  final def macroLogVerbose(msg: => Any): Unit

     Definition Classes

     Traces

     Annotations

     @inline()

185.  def macroRuntime(expandee: Global.Tree): MacroRuntime

     Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe.

     Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe. 2) Loads its enclosing class from the macro classloader. 3) Loads the companion of that enclosing class from the macro classloader. 4) Resolves macro implementation within the loaded companion.

     returns

     Requested runtime if macro implementation can be loaded successfully from either of the mirrors, null otherwise.

     Definition Classes

     MacroRuntimes

186.  def makeNamedTypes(syms: List[Global.Symbol]): collection.immutable.List[Global.NamedType]

     Definition Classes

     NamesDefaults

187.  def markDynamicRewrite(tree: Global.Tree): Global.Tree

     Definition Classes

     StdAttachments

188.  def markExpanded(sym: Global.Symbol): Global.Symbol

     Definition Classes

     MacroAnnotationAttachments

189.  def markMacroImplRef(tree: Global.Tree): Global.Tree

     Marks the tree as a macro impl reference, which is a naked reference to a method.

     Marks the tree as a macro impl reference, which is a naked reference to a method.

     This is necessary for typechecking macro impl references (see DefaultMacroCompiler.defaultResolveMacroImpl), because otherwise typing a naked reference will result in the "follow this method with _ if you want to treat it as a partially applied function" errors.

     This mark suppresses adapt except for when the annottee is a macro application.

     Definition Classes

     StdAttachments

190.  def markMaybeExpandee(sym: Global.Symbol): Global.Symbol

     Definition Classes

     MacroAnnotationAttachments

191.  def markNotExpandable(sym: Global.Symbol): Global.Symbol

     Definition Classes

     MacroAnnotationAttachments

192.  def markWeak(sym: Global.Symbol): Global.Symbol

     Definition Classes

     MacroAnnotationAttachments

193.  def memberWildcardType(name: Global.Name, tp: Global.Type): Global.Type

     A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

     A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

     Definition Classes

     Implicits

194.  def minimizeParents(cls: Global.Symbol, parents: List[Global.Type]): List[Global.Type]

     Definition Classes

     Erasure

195.  def missingParams[T](args: List[T], params: List[Global.Symbol], argName: (T) => Option[Global.Name]): (List[Global.Symbol], Boolean)

     Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

     Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

     args

     The list of arguments

     params

     The list of parameter symbols of the invoked method

     argName

     A function that extracts the name of an argument expression, if it is a named argument.

     Definition Classes

     NamesDefaults

196.  final def ne(arg0: AnyRef): Boolean

     Definition Classes

     AnyRef

197.  def newNamer(context: Context): Namer

     Definition Classes

     Namers

198.  def newPhase(prev: nsc.Phase): StdPhase

     Create a new phase which applies transformer

     Create a new phase which applies transformer

     Definition Classes

     InfoTransform → Transform → SubComponent

199.  def newRootLocalTyper(unit: Global.CompilationUnit): (analyzer)#Typer

     Attributes

     protected

     Definition Classes

     TypingTransformers

200.  def newTransformer(unit: Global.CompilationUnit): Global.AstTransformer

     The transformer factory

     The transformer factory

     Definition Classes

     Erasure → Transform

201.  def newTyper(context: Context): Eraser

     Definition Classes

     Erasure → Typers

202.  def noPrintAdapt(tree1: Global.Tree, tree2: Global.Tree): Boolean

     Definition Classes

     TypersTracking

203.  def noPrintTyping(t: Global.Tree): Boolean

     Definition Classes

     TypersTracking

204.  def notAnyRefMessage(found: Global.Type): String

     Definition Classes

     ContextErrors

205.  final def notify(): Unit

     Definition Classes

     AnyRef

     Annotations

     @native()

206.  final def notifyAll(): Unit

     Definition Classes

     AnyRef

     Annotations

     @native()

207.  def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit

     Definition Classes

     Macros

208.  def notifyUndetparamsInferred(undetNoMore: List[Global.Symbol], inferreds: List[Global.Type]): Unit

     Definition Classes

     Macros

209.  def numericConversion(tree: Global.Tree, numericSym: Global.Symbol): Global.Tree

     Definition Classes

     Erasure

210.  def onTreeCheckerError(pos: Global.Position, msg: String): Unit

     Attributes

     protected

     Definition Classes

     Contexts

211.  def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]

     Definition Classes

     Macros

212.  def ownPhase: nsc.Phase

     The phase corresponding to this subcomponent in the current compiler run.

     The phase corresponding to this subcomponent in the current compiler run.

     Definition Classes

     SubComponent

213.  def pathPrefix: (List[String]) => String

     Definition Classes

     SplainFormatting

214.  val phaseName: String

     The name of the phase

     The name of the phase

     Definition Classes

     Erasure → SubComponent

215.  def phaseNewFlags: Long

     New flags defined by the phase which are not valid before

     New flags defined by the phase which are not valid before

     Definition Classes

     SubComponent

216.  def phaseNextFlags: Long

     New flags defined by the phase which are not valid until immediately after it

     New flags defined by the phase which are not valid until immediately after it

     Definition Classes

     SubComponent

217.  def pluginsEnsureCompanionObject(namer: Namer, cdef: Global.ClassDef, creator: (Global.ClassDef) => Global.Tree = companionModuleDef(_)): Global.Symbol
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsEnsureCompanionObject

218.  def pluginsEnterStats(typer: Typer, stats: List[Global.Tree]): List[Global.Tree]
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsEnterStats

219.  def pluginsEnterSym(namer: Namer, tree: Global.Tree): Context
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsEnterSym

220.  def pluginsIsBlackbox(macroDef: Global.Symbol): Boolean
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsIsBlackbox

221.  def pluginsMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsMacroArgs

222.  def pluginsMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsMacroExpand

223.  def pluginsMacroRuntime(expandee: Global.Tree): MacroRuntime
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsMacroRuntime

224.  def pluginsNoImplicitFoundError(param: Global.Symbol, errors: List[ImplicitError], initial: String): String
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.noImplicitFoundError

225.  def pluginsNotifyImplicitSearch(search: ImplicitSearch): Unit
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsImplicitSearch

226.  def pluginsNotifyImplicitSearchResult(result: SearchResult): Unit
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsImplicitSearchResult

227.  def pluginsPt(pt: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode): Global.Type
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsPt

228.  def pluginsTypeSig(tpe: Global.Type, typer: Typer, defTree: Global.Tree, pt: Global.Type): Global.Type
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsTypeSig

229.  def pluginsTypeSigAccessor(tpe: Global.Type, typer: Typer, tree: Global.ValDef, sym: Global.Symbol): Global.Type
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsTypeSigAccessor

230.  def pluginsTyped(tpe: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Type
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsTyped

231.  def pluginsTypedMacroBody(typer: Typer, ddef: Global.DefDef): Global.Tree
     Definition Classes

     AnalyzerPlugins

     See also

     MacroPlugin.pluginsTypedMacroBody

232.  def pluginsTypedReturn(tpe: Global.Type, typer: Typer, tree: Global.Return, pt: Global.Type): Global.Type
     Definition Classes

     AnalyzerPlugins

     See also

     AnalyzerPlugin.pluginsTypedReturn

233.  def popMacroContext(): Unit

     Definition Classes

     Macros

234.  def posPrecedes(p1: Global.Position, p2: Global.Position): Boolean

     Does the positioned line assigned to t1 precede that of t2?

     Does the positioned line assigned to t1 precede that of t2?

     Definition Classes

     TypeDiagnostics

235.  val prepareSigMap: Global.TypeMap { def squashBoxed(tp: scala.tools.nsc.Global.erasure.global.Type): scala.tools.nsc.Global.erasure.global.Type }

     This object is only used for sanity testing when -check:genjvm is set.

     This object is only used for sanity testing when -check:genjvm is set. In that case we make sure that the erasure of the normalized type is the same as the erased type that's generated. Normalization means unboxing some primitive types and further simplifications as they are done in jsig.

     Definition Classes

     Erasure

236.  def printingOk(t: Global.Tree): Boolean

     Definition Classes

     TypersTracking

237.  def propagateKnownTypes(from: Global.Type, to: Global.Symbol): Global.Type

     The applied type of class 'to' after inferring anything possible from the knowledge that 'to' must also be of the type given in 'from'.

     The applied type of class 'to' after inferring anything possible from the knowledge that 'to' must also be of the type given in 'from'.

     Definition Classes

     Checkable

238.  def pushMacroContext(c: MacroContext): Unit

     Definition Classes

     Macros

239.  def qualifiedName(path: List[String], name: FormattedName): String

     Definition Classes

     SplainFormatting

240.  def rebindInnerClass(pre: Global.Type, cls: Global.Symbol): Global.Type

     Attributes

     protected

     Definition Classes

     Erasure

241.  final def recursivelyFinal(tpe: Global.Type): Boolean

     Definition Classes

     TypeDiagnostics

     Annotations

     @tailrec()

242.  def registerImport(ctx: Context, imp: Global.Import): Unit

     Definition Classes

     Contexts

243.  def removeNames(typer: Typer)(args: List[Global.Tree], params: List[Global.Symbol]): (List[Global.Tree], Array[Int])

     Removes name assignments from args.

     Removes name assignments from args. Additionally, returns an array mapping argument indices from call-site-order to definition-site-order.

     Verifies that names are not specified twice, and positional args don't appear after named ones.

     Definition Classes

     NamesDefaults

244.  def reorderArgs[T](args: List[T], pos: (Int) => Int)(implicit arg0: ClassTag[T]): List[T]
     pos

     maps indices from old to new

     Definition Classes

     NamesDefaults

245.  val requiredDirectInterfaces: AnyRefMap[Global.Symbol, Set[Global.Symbol]]

     Definition Classes

     Erasure

246.  val requires: List[String]

     Names of phases required by this component.

     Names of phases required by this component. Default is Nil.

     Definition Classes

     SubComponent

247.  def resetContexts(): Unit

     Definition Classes

     Contexts

248.  def resetDocComments(): Unit

     Definition Classes

     Typers

249.  def resetImplicits(): Unit

     Definition Classes

     Implicits

250.  def resetTyper(): Unit

     Definition Classes

     Typers

251.  final def resolveAnonymousBridgeClash(sym: Global.Symbol, bridge: Global.Symbol): Unit

     Definition Classes

     Erasure

252.  def restoreCompleter(sym: Global.Symbol): Unit

     Definition Classes

     MacroAnnotationAttachments

253.  def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

     Definition Classes

     TypeDiagnostics

254.  def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String, category: WarningCategory, site: Global.Symbol): Unit

     For errors which are artifacts of the implementation: such messages indicate that the restriction may be lifted in the future.

     For errors which are artifacts of the implementation: such messages indicate that the restriction may be lifted in the future.

     Definition Classes

     TypeDiagnostics

255.  def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context

     Definition Classes

     Contexts

256.  def rootContextPostTyper(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree): Context

     Definition Classes

     Contexts

257.  def rootImports(unit: Global.CompilationUnit): List[Global.Symbol]

     List of symbols to import from in a root context.

     List of symbols to import from in a root context. By default, that is java.lang, scala, and scala.Predef, in that order.

     • if option -Yimports is supplied, then that specifies the preamble imports
     • if the unit body has an import of Predef among its leading imports, or if the tree is scala.Predef, Predef is not imported. Similarly for any module among the preamble imports.
     • if the unit is java defined, only java.lang is imported

     The root imports for a unit are cached.

     Attributes

     protected

     Definition Classes

     Contexts

258.  val rootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]

     Definition Classes

     Contexts

259.  val runsAfter: collection.immutable.List[String]

     Names of phases that must run before this phase.

     Names of phases that must run before this phase.

     Definition Classes

     erasure → SubComponent

260.  val runsBefore: List[String]

     Names of phases that must run after this phase.

     Names of phases that must run after this phase. Default is Nil.

     Definition Classes

     SubComponent

261.  val runsRightAfter: Some[String]

     Name of the phase that this phase must follow immediately.

     Name of the phase that this phase must follow immediately.

     Definition Classes

     erasure → SubComponent

262.  def sanitizePath(path: List[String]): List[String]

     Definition Classes

     SplainFormatting

263.  def setAddendum(pos: Global.Position, msg: () => String): Unit

     Definition Classes

     TypeDiagnostics

264.  final val shortenImports: Boolean(false)

     Definition Classes

     Typers

265.  def showFormatted(tpe: Formatted): String

     Definition Classes

     SplainFormatting

266.  def showFormattedL(tpe: Formatted, break: Boolean): TypeRepr

     Definition Classes

     SplainFormatting

267.  val showFormattedLCache: FormatCache[(Formatted, Boolean), TypeRepr]

     Definition Classes

     SplainFormatting

268.  def showFormattedLImpl(tpe: Formatted, break: Boolean): TypeRepr

     Definition Classes

     SplainFormatting

269.  def showFormattedQualified(path: List[String], name: FormattedName): TypeRepr

     Definition Classes

     SplainFormatting

270.  def showFuncParams(args: List[String]): String

     Definition Classes

     SplainFormatting

271.  def showRefined(parents: List[String], decls: List[String]): String

     Definition Classes

     SplainFormatting

272.  def showTuple(args: List[String]): String

     Definition Classes

     SplainFormatting

273.  def showType(tpe: Global.Type): String

     Definition Classes

     SplainFormatting

274.  def showTypeApply(cons: String, args: List[TypeRepr], break: Boolean): TypeRepr

     If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.

     If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.

     Definition Classes

     SplainFormatting

275.  def showTypeBreakL(tpe: Global.Type): List[String]

     Definition Classes

     SplainFormatting

276.  def skipImplicit(tp: Global.Type): Global.Type

     Definition Classes

     Infer

277.  def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], getVariance: Extractor[Global.Symbol], upper: Boolean, depth: Depth): List[Global.Type]

     Solve constraint collected in types tvars.

     Solve constraint collected in types tvars.

     tvars

     All type variables to be instantiated.

     tparams

     The type parameters corresponding to tvars

     getVariance

     Function to extract variances of type parameters; we need to reverse solution direction for all contravariant variables.

     upper

     When true search for max solution else min.

     Definition Classes

     Infer

     Exceptions thrown

278.  def specialConstructorErasure(clazz: Global.Symbol, tpe: Global.Type): Global.Type

     Definition Classes

     Erasure

279.  def specialErasure(sym: Global.Symbol)(tp: Global.Type): Global.Type

     Definition Classes

     Erasure

280.  val specialFormatters: List[SpecialFormatter]

     Definition Classes

     SplainFormatting

281.  def specialScalaErasureFor(sym: Global.Symbol): ErasureMap

     Definition Classes

     Erasure

282.  def splainFoundReqMsg(found: Global.Type, req: Global.Type): String

     Definition Classes

     SplainDiagnostics

283.  def splainPushImplicitSearchFailure(implicitTree: Global.Tree, expectedType: Global.Type, originalError: AbsTypeError): Unit

     Definition Classes

     SplainErrors

284.  def splainPushNonconformantBonds(tpe: Global.Type, candidate: Global.Tree, targs: List[Global.Type], tparams: List[Global.Symbol], originalError: Option[AbsTypeError]): Unit

     Definition Classes

     SplainErrors

285.  def splainPushNotFound(tree: Global.Tree, param: Global.Symbol): Unit

     Definition Classes

     SplainErrors

286.  def splainPushOrReportNotFound(tree: Global.Tree, param: Global.Symbol, annotationMsg: String): String

     Definition Classes

     SplainErrors

287.  def splitChains(errors: List[ImplicitError]): List[List[ImplicitError]]

     Definition Classes

     SplainFormatting

288.  def standardIsBlackbox(macroDef: Global.Symbol): Boolean

     Default implementation of isBlackbox.

     Default implementation of isBlackbox. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsIsBlackbox for more details)

     Definition Classes

     Macros

289.  def standardMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

     Default implementation of macroArgs.

     Default implementation of macroArgs. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroArgs for more details)

     Definition Classes

     Macros

290.  def standardMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

     Default implementation of macroExpand.

     Default implementation of macroExpand. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroExpand for more details)

     Definition Classes

     Macros

291.  def standardMacroRuntime(expandee: Global.Tree): MacroRuntime

     Definition Classes

     MacroRuntimes

292.  def standardTypedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

     Default implementation of typedMacroBody.

     Default implementation of typedMacroBody. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsTypedMacroBody for more details)

     Definition Classes

     Macros

293.  def stripModules(path: List[String], name: FormattedName): String

     Definition Classes

     SplainFormatting

294.  def stripType(tpe: Global.Type): (List[String], String)

     Definition Classes

     SplainFormatting

295.  def superArgs(tree: Global.Tree): Option[List[List[Global.Tree]]]

     Convenience method for SuperArgsAttachment.

     Convenience method for SuperArgsAttachment. Compared with MacroRuntimeAttachment this attachment has different a usage pattern, so it really benefits from a dedicated extractor.

     Definition Classes

     StdAttachments

296.  def suppressMacroExpansion(tree: Global.Tree): Global.Tree

     Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.

     Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.

     Definition Classes

     StdAttachments

297.  def symbolPath(sym: Global.Symbol): List[String]

     Definition Classes

     SplainFormatting

298.  final def synchronized[T0](arg0: => T0): T0

     Definition Classes

     AnyRef

299.  val terminal: Boolean

     True if this phase runs after all other phases.

     True if this phase runs after all other phases. Usually, terminal.

     Definition Classes

     SubComponent

300.  def toString(): String

     Definition Classes

     AnyRef → Any

301.  def tpe_s(tp: Global.Type, colorize: (String) => String): String

     Definition Classes

     TypersTracking

302.  def transformInfo(sym: Global.Symbol, tp: Global.Type): Global.Type

     Definition Classes

     Erasure

303.  def transformNamedApplication(typer: Typer, mode: Mode, pt: Global.Type)(tree: Global.Tree, argPos: (Int) => Int): Global.Tree

     Transform a function application into a Block, and assigns typer.context .namedApplyBlockInfo to the new block as side-effect.

     Transform a function application into a Block, and assigns typer.context .namedApplyBlockInfo to the new block as side-effect. If tree has the form Apply(fun, args) first the function "fun" (which might be an application itself!) is transformed into a block of the form { val qual$1 = qualifier_of_fun val x$1 = arg_1_of_fun ... val x$n = arg_n_of_fun qual$1.fun[targs](x$1, ...)...(..., x$n) } then for each argument in args, a value is created and entered into the block. finally the application expression of the block is updated. { val qual$1 = .. ... val x$n = ... > val qual$n+1 = arg(1) > ... > val qual$n+m = arg(m) > qual$1.fun[targs](x$1, ...)...(..., x$n)(x$n+1, ..., x$n+m) }

     typer

     the typer calling this method; this method calls typer.doTypedApply

     mode

     the mode to use for calling typer.doTypedApply

     pt

     the expected type for calling typer.doTypedApply

     tree

     the function application tree

     argPos

     a function mapping arguments from their current position to the position specified by the method type. example: def foo(a: Int, b: String) foo(b = "1", a = 2) calls transformNamedApplication(Apply(foo, List("1", 2), { 0 => 1, 1 => 0 })

     returns

     the transformed application (a Block) together with the NamedApplyInfo. if isNamedApplyBlock(tree), returns the existing context.namedApplyBlockInfo

     Definition Classes

     NamesDefaults

304.  def transformTypeTagEvidenceParams(macroImplRef: Global.Tree, transform: (Global.Symbol, Global.Symbol) => Global.Symbol): List[List[Global.Symbol]]

     Transforms parameters lists of a macro impl.

     Transforms parameters lists of a macro impl. The transform function is invoked only for WeakTypeTag evidence parameters.

     The transformer takes two arguments: a value parameter from the parameter list and a type parameter that is witnesses by the value parameter.

     If the transformer returns a NoSymbol, the value parameter is not included from the result. If the transformer returns something else, this something else is included in the result instead of the value parameter.

     Despite of being highly esoteric, this function significantly simplifies signature analysis. For example, it can be used to strip macroImpl.paramss from the evidences (necessary when checking def <-> impl correspondence) or to streamline creation of the list of macro arguments.

     Definition Classes

     Helpers

305.  def transparentDealias(sym: Global.Symbol, pre: Global.Type, owner: Global.Symbol): Global.Type

     Definition Classes

     Erasure

306.  def treeSymTypeMsg(tree: Global.Tree): String

     Definition Classes

     TypeDiagnostics

307.  def truncateDecls(decls: List[Formatted]): Boolean

     Definition Classes

     SplainFormatting

308.  def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String

     Definition Classes

     TypeDiagnostics

309.  def typedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

     Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle, and that that method is signature-wise compatible with the given macro definition.

     Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle, and that that method is signature-wise compatible with the given macro definition.

     returns

     Macro impl reference for the given macro definition if everything is okay. EmptyTree if an error occurs.

     Definition Classes

     Macros

310.  def typerShouldExpandDeferredMacros: Boolean

     Definition Classes

     Macros

311.  def typingInPattern[T](body: => T): T

     Devising new ways of communicating error info out of desperation to work on error messages.

     Devising new ways of communicating error info out of desperation to work on error messages. This is used by typedPattern to wrap its business so we can generate a sensible error message when things go south.

     Definition Classes

     TypeDiagnostics

312.  def unapplyMember(tp: Global.Type): Global.Symbol

     Filters out unapplies with invalid shapes: extractor methods must have either one unary param list or one unary param list and an implicit param list.

     Filters out unapplies with invalid shapes: extractor methods must have either one unary param list or one unary param list and an implicit param list.

     Definition Classes

     Unapplies

313.  def unboundedGenericArrayLevel(tp: Global.Type): Int

     Definition Classes

     Erasure

314.  def underlyingSymbol(member: Global.Symbol): Global.Symbol

     The symbol which the given accessor represents (possibly in part).

     The symbol which the given accessor represents (possibly in part). This is used for error messages, where we want to speak in terms of the actual declaration or definition, not in terms of the generated setters and getters.

     TODO: is it wise to create new symbols simply to generate error message? is this safe in interactive/resident mode?

     Definition Classes

     TypeDiagnostics

315.  def unmarkDynamicRewrite(tree: Global.Tree): Global.Tree

     Definition Classes

     StdAttachments

316.  def unmarkExpanded(sym: Global.Symbol): Global.Symbol

     Definition Classes

     MacroAnnotationAttachments

317.  def unmarkMacroImplRef(tree: Global.Tree): Global.Tree

     Unmarks the tree as a macro impl reference (see markMacroImplRef for more information).

     Unmarks the tree as a macro impl reference (see markMacroImplRef for more information).

     This is necessary when a tree that was previously deemed to be a macro impl reference, typechecks to be a macro application. Then we need to unmark it, expand it and try to treat its expansion as a macro impl reference.

     Definition Classes

     StdAttachments

318.  def unmarkWeak(sym: Global.Symbol): Global.Symbol

     Definition Classes

     MacroAnnotationAttachments

319.  def unsuppressMacroExpansion(tree: Global.Tree): Global.Tree

     Unsuppresses macro expansion of the tree by removing SuppressMacroExpansionAttachment from it and its children.

     Unsuppresses macro expansion of the tree by removing SuppressMacroExpansionAttachment from it and its children.

     Definition Classes

     StdAttachments

320.  def untypeMetalevel(tp: Global.Type): Global.Type

     Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.

     Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.

     Definition Classes

     Helpers

321.  final def validateUnapplyMember(tp: Global.Type): typechecker.Unapplies.UnapplyMemberResult.Value

     Definition Classes

     Unapplies

     Annotations

     @tailrec()

322.  def valueClassIsParametric(clazz: Global.Symbol): Boolean

     Definition Classes

     Erasure

323.  def verifyJavaErasure: Boolean

     Attributes

     protected

     Definition Classes

     Erasure → Erasure

324.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

325.  final def wait(arg0: Long, arg1: Int): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

326.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException]) @native()

327.  def warnUnusedImports(unit: Global.CompilationUnit): Unit

     Definition Classes

     Contexts

328.  def withAddendum(pos: Global.Position): (String) => String

     Definition Classes

     TypeDiagnostics

329.  def withDisambiguation[T](locals: List[Global.Symbol], types: Global.Type*)(op: => T): T

     Given any number of types, alters the name information in the symbols until they can be distinguished from one another: then executes the given code.

     Given any number of types, alters the name information in the symbols until they can be distinguished from one another: then executes the given code. The names are restored and the result is returned.

     Definition Classes

     TypeDiagnostics

330.  def wrapParens(expr: String, top: Boolean): String

     Definition Classes

     SplainFormatting

331.  def wrapParensRepr(tpe: TypeRepr, top: Boolean): TypeRepr

     Definition Classes

     SplainFormatting

332.  object GenericArray

     Definition Classes

     Erasure

333.  object javaErasure extends JavaErasureMap

     Definition Classes

     Erasure

334.  object specialScalaErasure extends ScalaErasureMap with SpecialScalaErasure

     Definition Classes

     Erasure

335.  object CODE

     Definition Classes

     TreeDSL

336.  object namerFactory extends SubComponent

     Definition Classes

     Analyzer

337.  object packageObjects extends SubComponent

     Definition Classes

     Analyzer

338.  object typerFactory extends SubComponent

     Definition Classes

     Analyzer

339.  object Checkability

     Definition Classes

     Checkable

340.  object ErrorUtils

     Definition Classes

     ContextErrors

341.  object NamesDefaultsErrorsGen

     Definition Classes

     ContextErrors

342.  object NoContext extends Analyzer.Context

     Definition Classes

     Contexts

343.  object Function1

     An extractor for unary function types arg => res

     An extractor for unary function types arg => res

     Definition Classes

     Implicits

344.  object HasMember

     An extractor for types of the form ? { name: ? }

     An extractor for types of the form ? { name: ? }

     Definition Classes

     Implicits

345.  object HasMethodMatching

     An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }

     An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }

     Definition Classes

     Implicits

346.  object ImplicitAmbiguousMsg extends Analyzer.ImplicitAnnotationMsg

     Definition Classes

     Implicits

347.  object ImplicitNotFoundMsg extends Analyzer.ImplicitAnnotationMsg

     Definition Classes

     Implicits

348.  object OpenImplicit extends java.io.Serializable

     Definition Classes

     Implicits

349.  object Shadower

     Definition Classes

     Implicits

350.  object approximateAbstracts extends Global.TypeMap

     Definition Classes

     Infer

351.  object instantiate extends Global.TypeMap

     Map every TypeVar to its constraint.inst field.

     Map every TypeVar to its constraint.inst field. throw a NoInstance exception if a NoType or WildcardType is encountered.

     Definition Classes

     Infer

352.  object toOrigin extends Global.TypeMap

     Definition Classes

     Infer

353.  case object WeakSymbolAttachment extends Product with Serializable

     Definition Classes

     MacroAnnotationAttachments

354.  object MacroImplBinding extends java.io.Serializable

     Definition Classes

     Macros

355.  object NamedApplyBlock

     Definition Classes

     NamesDefaults

356.  case object DynamicRewriteAttachment extends Product with Serializable

     Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected from typedNamedApply, the applyDynamicNamed argument rewriter, the latter doesn’t know whether it needs to apply the rewriting because the application has just been desugared or it needs to hold on because it’s already performed a desugaring on this tree.

     Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected from typedNamedApply, the applyDynamicNamed argument rewriter, the latter doesn’t know whether it needs to apply the rewriting because the application has just been desugared or it needs to hold on because it’s already performed a desugaring on this tree. This has led to scala/bug#8006.

     This attachment solves the problem by providing a means of communication between the two Dynamic desugarers, which solves the aforementioned issue.

     Definition Classes

     StdAttachments

357.  case object MacroImplRefAttachment extends Product with Serializable
     Definition Classes

     StdAttachments

     See also

     markMacroImplRef

358.  case 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

359.  case object TypedExpectingUnitAttachment extends Product with Serializable

     Marks a Typed tree with Unit tpt.

     Marks a Typed tree with Unit tpt.

     Definition Classes

     StdAttachments

360.  object UnusedPrivates

     Definition Classes

     TypeDiagnostics

361.  object checkDead

     Definition Classes

     TypeDiagnostics

362.  object SilentTypeError

     Definition Classes

     Typers

363.  object checkNoEscaping extends Global.TypeMap

     Check that type of given tree does not contain local or private components.

     Check that type of given tree does not contain local or private components.

     Definition Classes

     Typers

364.  object typingStack

     Definition Classes

     TypersTracking

365.  object HasUnapply

     Definition Classes

     Unapplies

366.  object UnapplyMemberResult extends Enumeration

     Definition Classes

     Unapplies

367.  object ImplicitError extends java.io.Serializable

     Definition Classes

     SplainData

368.  object ImplicitErrorSpecifics

     Definition Classes

     SplainData

369.  object ImplicitErrors

     Definition Classes

     SplainData

370.  object ByNameFormatter extends Analyzer.SpecialFormatter

     Definition Classes

     SplainFormatters

371.  object FunctionFormatter extends Analyzer.SpecialFormatter

     Definition Classes

     SplainFormatters

372.  object Refined

     Definition Classes

     SplainFormatters

373.  object RefinedFormatter extends Analyzer.SpecialFormatter

     Definition Classes

     SplainFormatters

374.  object TupleFormatter extends Analyzer.SpecialFormatter

     Definition Classes

     SplainFormatters