scala.tools.nsc.typechecker

# Analyzer

#### trait Analyzer extends Contexts with Namers with Typers with Infer with Implicits with Variances with EtaExpansion with SyntheticMethods with Unapplies with Macros with NamesDefaults with TypeDiagnostics with ContextErrors with StdAttachments with AnalyzerPlugins

The main attribution phase.

Linear Supertypes
AnalyzerPlugins, StdAttachments, ContextErrors, TypeDiagnostics, NamesDefaults, Macros, Traces, FastTrack, Unapplies, SyntheticMethods, TreeDSL, EtaExpansion, Variances, Implicits, Infer, Checkable, Typers, Tags, Adaptations, Modes, Namers, MethodSynthesis, Contexts, AnyRef, Any
Known Subclasses
Duplicator, Duplicators, Erasure, SpecializationDuplicator, TreeCheckers, erasure, treeChecker
Type Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Analyzer
2. AnalyzerPlugins
3. StdAttachments
4. ContextErrors
5. TypeDiagnostics
6. NamesDefaults
7. Macros
8. Traces
9. FastTrack
10. Unapplies
11. SyntheticMethods
12. TreeDSL
13. EtaExpansion
14. Variances
15. Implicits
16. Infer
17. Checkable
18. Typers
19. Tags
20. Adaptations
21. Modes
22. Namers
23. MethodSynthesis
24. Contexts
25. AnyRef
26. 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

### Type Members

1. #### trait AbsTypeError extends Throwable

   Definition Classes
     ContextErrors

2. #### trait Adaptation extends AnyRef

   Definition Classes
     Adaptations

3. #### case class AmbiguousTypeError (underlyingTree: Global.Tree, errPos: Global.Position, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

   Definition Classes
     ContextErrors

4. #### trait AnalyzerPlugin extends AnyRef

   Definition Classes
     AnalyzerPlugins

5. #### class ClassForCaseCompanionAttachment extends AnyRef

   Definition Classes
     Unapplies

6. #### class ClassMethodSynthesis extends AnyRef

   Definition Classes
     MethodSynthesis

7. #### class ConstructorDefaultsAttachment extends AnyRef

   Definition Classes
     NamesDefaults

8. #### class Context extends AnyRef

   Definition Classes
     Contexts

9. #### class DefaultsOfLocalMethodAttachment extends AnyRef

   Definition Classes
     NamesDefaults

10. #### case class DivergentImplicitTypeError (tree: Global.Tree, pt0: Global.Type, sym: Global.Symbol) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

11. #### case class FastTrackEntry (sym: nsc.Global.Symbol, expander: (FastTrack.this)#FastTrackExpander) extends Product with Serializable

    Definition Classes
      FastTrack

12. #### type FastTrackExpander = PartialFunction[(MacroContext, Global.Tree), Global.Tree]

    Definition Classes
      FastTrack

13. #### class ImplicitInfo extends AnyRef

    A class that records an available implicit

14. #### class ImplicitSearch extends Analyzer.Typer with Analyzer.ImplicitsContextErrors

    A class that sets up an implicit search.

15. #### trait ImplicitsContextErrors extends AnyRef

    Definition Classes
      ContextErrors

16. #### class ImportInfo extends AnyRef

    Definition Classes
      Contexts

17. #### case class ImportType (expr: Global.Tree) extends Global.Type with Product with Serializable

    Definition Classes
      Contexts

18. #### trait InferCheckable extends AnyRef

    Definition Classes
      Checkable

19. #### class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

    The context-dependent inferencer part

20. #### trait InferencerContextErrors extends AnyRef

    Definition Classes
      ContextErrors

21. #### trait LockingTypeCompleter extends Analyzer.TypeCompleter

    Definition Classes
      Namers

22. #### case class MacroArgs (c: Analyzer.MacroContext, others: List[Any]) extends Product with Serializable

    Calculate the arguments to pass to a macro implementation when expanding the provided tree.

23. #### type MacroContext = UnaffiliatedMacroContext { val universe: Analyzer.this.global.type }

    Definition Classes
      StdAttachments

24. #### trait MacroErrors extends AnyRef

    Definition Classes
      ContextErrors

25. #### type MacroRuntime = (MacroArgs) ⇒ Any

    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
      Macros

26. #### case class MacroRuntimeAttachment (delayed: Boolean, typerContext: Analyzer.Context, macroContext: Option[Analyzer.MacroContext]) extends Product with Serializable

    Definition Classes
      StdAttachments

27. #### class MacroTyper extends Analyzer.MacroErrors

    Definition Classes
      Macros

28. #### trait MethodSynth extends AnyRef

    There are two key methods in here.

29. #### case class NamedApplyInfo (qual: Option[Global.Tree], targs: List[Global.Tree], vargss: List[List[Global.Tree]], blockTyper: Analyzer.Typer) extends Product with Serializable

    Definition Classes
      NamesDefaults

30. #### abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors

    Definition Classes
      Namers

31. #### trait NamerContextErrors extends AnyRef

    Definition Classes
      ContextErrors

32. #### class NoInstance extends Throwable with ControlThrowable

    Definition Classes
      Infer

33. #### case class NormalTypeError (underlyingTree: Global.Tree, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

34. #### case class OpenImplicit (info: Analyzer.ImplicitInfo, pt: Global.Type, tree: Global.Tree) extends Product with Serializable

    A class which is used to track pending implicits to prevent infinite implicit searches.

35. #### class PolyTypeCompleter extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter

    A class representing a lazy type with known type parameters.

36. #### case class PosAndMsgTypeError (errPos: Global.Position, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

37. #### class SearchResult extends AnyRef

    The result of an implicit search

38. #### sealed abstract class SilentResult [+T] extends AnyRef

    Definition Classes
      Typers

39. #### case class SilentResultValue [+T](value: T) extends Analyzer.SilentResult[T] with Product with Serializable

    Definition Classes
      Typers

40. #### case class SilentTypeError (err: Analyzer.AbsTypeError) extends Analyzer.SilentResult[Nothing] with Product with Serializable

    Definition Classes
      Typers

41. #### case class SymbolTypeError (underlyingSym: Global.Symbol, errMsg: String, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

42. #### trait Tag extends AnyRef

    Definition Classes
      Tags

43. #### abstract class TypeCompleter extends Global.LazyType

    Definition Classes
      Namers

44. #### case class TypeDiag (tp: Global.Type, sym: Global.Symbol) extends Ordered[Analyzer.TypeDiag] with Product with Serializable

    Definition Classes
      TypeDiagnostics

45. #### case class TypeErrorWithUnderlyingTree (tree: Global.Tree, ex: Global.TypeError, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

46. #### case class TypeErrorWrapper (ex: Global.TypeError, kind: ErrorKind = ...) extends Throwable with Analyzer.AbsTypeError with Product with Serializable

    Definition Classes
      ContextErrors

47. #### abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.TyperContextErrors

    Definition Classes
      Typers

48. #### trait TyperContextErrors extends AnyRef

    Definition Classes
      ContextErrors

49. #### trait TyperDiagnostics extends AnyRef

    Definition Classes
      TypeDiagnostics

50. #### type UnaffiliatedMacroContext = reflect.macros.runtime.Context

    Definition Classes
      StdAttachments

### Abstract Value Members

1. #### abstract val global: Global

   Definition Classes
     Analyzer → TreeDSL → Variances

### Concrete Value Members

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

   Definition Classes
     AnyRef

2. #### final def !=(arg0: Any): Boolean

   Definition Classes
     Any

3. #### final def ##(): Int

   Definition Classes
     AnyRef → Any

4. #### def +(other: String): String

   Implicit information
     This member is added by an implicit conversion from Analyzer to StringAdd performed by method any2stringadd in scala.Predef.
   Definition Classes
     StringAdd

5. #### def ->[B](y: B): (Analyzer, B)

   Implicit information
     This member is added by an implicit conversion from Analyzer to ArrowAssoc[Analyzer] 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

   Definition Classes
     Any

8. #### final val ALTmode: Int(8192)

   ALTmode is set when we are under a pattern alternative.

   ALTmode is set when we are under a pattern alternative.

   Definition Classes
     Modes

9. #### lazy val AmbiguousSearchFailure: SearchResult

   Definition Classes
     Implicits

10. #### final val BYVALmode: Int(32768)

    BYVALmode is set when we are typing an expression that occurs in a by-value position.

    BYVALmode is set when we are typing an expression that occurs in a by-value position. An expression e1 is in by-value position within expression e2 iff it will be reduced to a value at that position during the evaluation of e2. Examples are by-value function arguments or the conditional of an if-then-else clause. This mode has been added to support continuations.

    Definition Classes
      Modes

11. #### object CODE

    Definition Classes
      TreeDSL

12. #### lazy val DivergentSearchFailure: SearchResult

    Definition Classes
      Implicits

13. #### final val EXPRmode: Int(1)

    Definition Classes
      Modes

14. #### object ErrorKinds extends Enumeration

    Definition Classes
      ContextErrors

15. #### object ErrorUtils

    Definition Classes
      ContextErrors

16. #### final val FUNmode: Int(16)

    FUNmode is orthogonal to above.

    FUNmode is orthogonal to above. When set we are looking for a method or constructor.

    Definition Classes
      Modes

17. #### object Function1

    An extractor for unary function types arg => res

18. #### final val HKmode: Int(16384)

    HKmode is set when we are typing a higher-kinded type.

    HKmode is set when we are typing a higher-kinded type. adapt should then check kind-arity based on the prototypical type's kind arity. Type arguments should not be inferred.

    Definition Classes
      Modes

19. #### object HasMember

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

20. #### object HasMethodMatching

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

21. #### object ImplicitNotFoundMsg

    Definition Classes
      Implicits

22. #### final val LHSmode: Int(1024)

    LHSmode is set for the left-hand side of an assignment.

    LHSmode is set for the left-hand side of an assignment.

    Definition Classes
      Modes

23. #### object MacroBodyTypecheckException extends Exception with ControlThrowable with Product with Serializable

    Definition Classes
      ContextErrors

24. #### final val NOmode: Int(0)

    NOmode, EXPRmode and PATTERNmode are mutually exclusive.

    NOmode, EXPRmode and PATTERNmode are mutually exclusive.

    Definition Classes
      Modes

25. #### object NamesDefaultsErrorsGen

    Definition Classes
      ContextErrors

26. #### object NoContext extends Analyzer.Context

    Definition Classes
      Contexts

27. #### val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
      Implicits

28. #### final val PATTERNmode: Int(2)

    Definition Classes
      Modes

29. #### final val POLYmode: Int(32)

    POLYmode is orthogonal to above.

    POLYmode is orthogonal to above. When set expression types can be polymorphic.

    Definition Classes
      Modes

30. #### final val QUALmode: Int(64)

    QUALmode is orthogonal to above.

    QUALmode is orthogonal to above. When set expressions may be packages and Java statics modules.

    Definition Classes
      Modes

31. #### final val RETmode: Int(131072)

    RETmode is set when we are typing a return expression.

    RETmode is set when we are typing a return expression.

    Definition Classes
      Modes

32. #### final val SCCmode: Int(8)

    SCCmode is orthogonal to above.

    SCCmode is orthogonal to above. When set we are in the this or super constructor call of a constructor.

    Definition Classes
      Modes

33. #### final val SNDTRYmode: Int(512)

    SNDTRYmode indicates that an application is typed for the 2nd time.

    SNDTRYmode indicates that an application is typed for the 2nd time. In that case functions may no longer be coerced with implicit views.

    Definition Classes
      Modes

34. #### final val STARmode: Int(4096)

    STARmode is set when star patterns are allowed.

    STARmode is set when star patterns are allowed. (This was formerly called REGPATmode.)

    Definition Classes
      Modes

35. #### final val SUPERCONSTRmode: Int(256)

    SUPERCONSTRmode is set for the super in a superclass constructor call super.

    SUPERCONSTRmode is set for the super in a superclass constructor call super.<init>.

    Definition Classes
      Modes

36. #### lazy val SearchFailure: SearchResult

    Definition Classes
      Implicits

37. #### final val TAPPmode: Int(128)

    TAPPmode is set for the function/type constructor part of a type application.

    TAPPmode is set for the function/type constructor part of a type application. When set we do not decompose PolyTypes.

    Definition Classes
      Modes

38. #### final val TYPEPATmode: Int(65536)

    TYPEPATmode is set when we are typing a type in a pattern.

    TYPEPATmode is set when we are typing a type in a pattern.

    Definition Classes
      Modes

39. #### final val TYPEmode: Int(4)

    TYPEmode needs a comment.

    TYPEmode needs a comment. <-- XXX.

    Definition Classes
      Modes

40. #### object UnTyper extends Global.Traverser

    Definition Classes
      Typers

41. #### 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

42. #### def actualArgs(pos: Global.Position, actuals: List[Global.Tree], nformals: Int): List[Global.Tree]

    Definition Classes
      Infer

43. #### def actualTypes(actuals: List[Global.Type], nformals: Int): List[Global.Type]

    Definition Classes
      Infer

44. #### def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Int, pt: Global.Type): Global.Tree

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.adaptAnnotations

45. #### def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Registers a new analyzer plugin

    Registers a new analyzer plugin

    Definition Classes
      AnalyzerPlugins

46. #### def addDefaults(givenArgs: List[Global.Tree], qual: Option[Global.Tree], targs: List[Global.Tree], previousArgss: List[List[Global.Tree]], params: List[Global.Symbol], pos: 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

47. #### 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

48. #### 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).

    Definition Classes
      Implicits

49. #### def alternatives(tree: Global.Tree): List[Global.Type]

    Definition Classes
      TypeDiagnostics

50. #### def alternativesString(tree: Global.Tree): String

    Definition Classes
      TypeDiagnostics

51. #### final def asInstanceOf[T0]: T0

    Definition Classes
      Any

52. #### def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Int, pt: Global.Type): Boolean

    Definition Classes
      AnalyzerPlugins
    See also

      AnalyzerPlugin.canAdaptAnnotations

53. #### 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

54. #### 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 SI-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

55. #### 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

56. #### 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

57. #### 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

58. #### def clone(): AnyRef

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

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

    Definition Classes
      Unapplies

60. #### 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

61. #### def computeMacroDefTypeFromMacroImpl(macroDdef: Global.DefDef, macroImpl: Global.Symbol): Global.Type

    Definition Classes
      Macros

62. #### def copyUntyped[T <: Global.Tree](tree: T): T

    Definition Classes
      Unapplies

63. #### def copyUntypedInvariant(td: Global.TypeDef): Global.TypeDef

    Definition Classes
      Unapplies

64. #### def decodeWithKind(name: Global.Name, owner: Global.Symbol): String

    Definition Classes
      TypeDiagnostics

65. #### 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

66. #### def disambiguate(ss: List[String]): collection.immutable.List[String]

    Definition Classes
      TypeDiagnostics

67. #### def enclosingMacroPosition: Position

    Definition Classes
      Macros

68. #### def ensuring(cond: (Analyzer) ⇒ Boolean, msg: ⇒ Any): Analyzer

    Implicit information
      This member is added by an implicit conversion from Analyzer to Ensuring[Analyzer] performed by method any2Ensuring in scala.Predef.
    Definition Classes
      Ensuring

69. #### def ensuring(cond: (Analyzer) ⇒ Boolean): Analyzer

    Implicit information
      This member is added by an implicit conversion from Analyzer to Ensuring[Analyzer] performed by method any2Ensuring in scala.Predef.
    Definition Classes
      Ensuring

70. #### def ensuring(cond: Boolean, msg: ⇒ Any): Analyzer

    Implicit information
      This member is added by an implicit conversion from Analyzer to Ensuring[Analyzer] performed by method any2Ensuring in scala.Predef.
    Definition Classes
      Ensuring

71. #### def ensuring(cond: Boolean): Analyzer

    Implicit information
      This member is added by an implicit conversion from Analyzer to Ensuring[Analyzer] performed by method any2Ensuring in scala.Predef.
    Definition Classes
      Ensuring

72. #### final def eq(arg0: AnyRef): Boolean

    Definition Classes
      AnyRef

73. #### def equals(arg0: Any): Boolean

    Definition Classes
      AnyRef → Any

74. #### def etaExpand(unit: Global.CompilationUnit, tree: Global.Tree, typer: Typer): Global.Tree

    Expand partial function applications of type `type`.

    Expand partial function applications of type `type`.

         p.f(es_1)...(es_n)
            ==>  {
                   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))
                 }

    tree is already attributed

    Definition Classes
      EtaExpansion

75. #### object etaExpansion

    Definition Classes
      EtaExpansion

76. #### def existentialContext(tp: Global.Type): String

    Definition Classes
      TypeDiagnostics

77. #### def explainAlias(tp: Global.Type): String

    Definition Classes
      TypeDiagnostics

78. #### def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String

    Definition Classes
      TypeDiagnostics

79. #### 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

80. #### def extractorFormalTypes(pos: Global.Position, resTp: Global.Type, nbSubPats: Int, unappSym: Global.Symbol, effectiveNbSubPats: Int): (List[Global.Type], List[Global.Type])

    Returns `(formals, formalsExpanded)` where `formalsExpanded` are the expected types for the `nbSubPats` sub-patterns of an extractor pattern, of which the corresponding unapply[Seq] call is assumed to have result type `resTp`.

    Returns `(formals, formalsExpanded)` where `formalsExpanded` are the expected types for the `nbSubPats` sub-patterns of an extractor pattern, of which the corresponding unapply[Seq] call is assumed to have result type `resTp`.

    `formals` are the formal types before expanding a potential repeated parameter (must come last in `formals`, if at all)

    nbSubPats

      The number of arguments to the extractor pattern

    effectiveNbSubPats

      `nbSubPats`, unless there is one sub-pattern which, after unwrapping bind patterns, is a Tuple pattern, in which case it is the number of elements. Used to issue warnings about binding a `TupleN` to a single value.

    Definition Classes
      Infer
    Exceptions thrown
      TypeError

      when the unapply[Seq] definition is ill-typed

81. #### 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

82. #### lazy val fastTrack: Map[Global.Symbol, FastTrackEntry]

    Definition Classes
      FastTrack

83. #### implicit def fastTrackEntry2MacroRuntime(entry: FastTrackEntry): (MacroArgs) ⇒ Any

    Definition Classes
      FastTrack

84. #### def finalize(): Unit

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

85. #### final def forArgMode(fun: Global.Tree, mode: Int): Int

    Definition Classes
      Typers

86. #### final def forFunMode(mode: Int): Int

    Definition Classes
      Modes

87. #### final def forTypeMode(mode: Int): Int

    Definition Classes
      Modes

88. #### def formalTypes(formals: List[Global.Type], nargs: 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 (nargs - params.length + 1) copies of its type is returned. 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

89. #### def formatted(fmtstr: String): String

    Implicit information
      This member is added by an implicit conversion from Analyzer to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @inline()

90. #### def foundReqMsg(found: Global.Type, req: Global.Type): String

    Definition Classes
      TypeDiagnostics

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

    tparam

      ...

    returns

      ...

    Definition Classes
      Infer

92. #### final def getClass(): Class[_]

    Definition Classes
      AnyRef → Any

93. #### def globalSettings: Settings

    Definition Classes
      Macros → Traces

94. #### var 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

95. #### def hashCode(): Int

    Definition Classes
      AnyRef → Any

96. #### final def inAllModes(mode: Int, required: Int): Boolean

    Definition Classes
      Modes

97. #### final def inAnyMode(mode: Int, required: Int): Boolean

    Definition Classes
      Modes

98. #### final def inExprModeButNot(mode: Int, prohibited: Int): Boolean

    Definition Classes
      Modes

99. #### final def inExprModeOr(mode: Int, others: Int): Boolean

    Definition Classes
      Modes

100. #### final def inFunMode(mode: Int): Boolean

     Definition Classes
       Modes

101. #### final def inHKMode(mode: Int): Boolean

     Definition Classes
       Modes

102. #### final def inNoModes(mode: Int, prohibited: Int): Boolean

     Definition Classes
       Modes

103. #### final def inPatternMode(mode: Int): Boolean

     Definition Classes
       Modes

104. #### final def inPolyMode(mode: Int): Boolean

     Definition Classes
       Modes

105. #### 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

106. #### 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. 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 is 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 NoPosition, then position-based services will use `tree.pos`

     returns

       A search result

     Definition Classes
       Implicits

107. #### def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult

     Definition Classes
       Implicits

108. #### def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult

     Definition Classes
       Implicits

109. #### object instantiate extends Global.TypeMap

     Map every TypeVar to its constraint.

110. #### def isIdentity(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

111. #### final def isInstanceOf[T0]: Boolean

     Definition Classes
       Any

112. #### def isNamed(arg: Global.Tree): Boolean

     Definition Classes
       NamesDefaults

113. #### var lastAccessCheckDetails: String

     Definition Classes
       Contexts

114. #### var lastTreeToTyper: Global.Tree

     Definition Classes
       Typers

115. #### def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean

     Definition Classes
       TypeDiagnostics

116. #### def lockedCount: Int

     Definition Classes
       Namers

117. #### lazy val macroClassloader: ClassLoader

     Macro classloader that is used to resolve and run macro implementations.

     Macro classloader that is used to resolve and run macro implementations. Loads classes from from -cp (aka the library classpath). Is also capable of detecting REPL and reusing its classloader.

     Definition Classes
       Macros

118. #### val macroDebugLite: Boolean

     Definition Classes
       Traces

119. #### val macroDebugVerbose: Boolean

     Definition Classes
       Traces

120. #### def macroExpand(typer: Typer, expandee: Global.Tree, mode: Int = EXPRmode, pt: Global.Type = WildcardType): Global.Tree

     Performs macro expansion: 1) Checks whether the expansion needs to be delayed (see `mustDelayMacroExpansion`) 2) Loads macro implementation using `macroMirror` 3) Synthesizes invocation arguments for the macro implementation 4) Checks that the result is a tree bound to this universe 5) Typechecks the result against the return type of the macro definition

     Performs macro expansion: 1) Checks whether the expansion needs to be delayed (see `mustDelayMacroExpansion`) 2) Loads macro implementation using `macroMirror` 3) Synthesizes invocation arguments for the macro implementation 4) Checks that the result is a tree bound to this universe 5) Typechecks the result against the return type of the macro definition

     If -Ymacro-debug-lite is enabled, you will get basic notifications about macro expansion along with macro expansions logged in the form that can be copy/pasted verbatim into REPL.

     If -Ymacro-debug-verbose is enabled, you will get detailed log of how exactly this function performs class loading and method resolution in order to load the macro implementation. The log will also include other non-trivial steps of macro expansion.

     returns

       the expansion result if the expansion has been successful, the fallback method invocation if the expansion has been unsuccessful, but there is a fallback, the expandee unchanged if the expansion has been delayed, the expandee fully expanded if the expansion has been delayed before and has been expanded now, the expandee with an error marker set if the expansion has been cancelled due malformed arguments or implementation the expandee with an error marker set if there has been an error

     Definition Classes
       Macros

121. #### 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

122. #### final def macroLogLite(msg: ⇒ Any): Unit

     Definition Classes
       Traces
     Annotations
       @inline()

123. #### final def macroLogVerbose(msg: ⇒ Any): Unit

     Definition Classes
       Traces
     Annotations
       @inline()

124. #### 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

125. #### def missingParams[T](args: List[T], params: List[Global.Symbol], argName: (T) ⇒ Option[Global.Name] = nameOf): (List[Global.Symbol], Boolean)

     Definition Classes
       NamesDefaults

126. #### def mkTypeCompleter(t: Global.Tree)(c: (Global.Symbol) ⇒ Unit): TypeCompleter with LockingTypeCompleter

     Definition Classes
       Namers

127. #### def modeString(mode: Int): String

     Definition Classes
       Modes

128. #### def nameOf(arg: Global.Tree): Option[Global.Name]

     Definition Classes
       NamesDefaults

129. #### object namerFactory extends SubComponent

130. #### final def ne(arg0: AnyRef): Boolean

     Definition Classes
       AnyRef

131. #### def newNamer(context: Context): Namer

     Definition Classes
       Namers

132. #### def newNamerFor(context: Context, tree: Global.Tree): Namer

     Definition Classes
       Namers

133. #### def newTyper(context: Context): Typer

     Definition Classes
       Typers

134. #### val noApplyInfo: NamedApplyInfo

     Definition Classes
       NamesDefaults

135. #### def noErroneousSyms(syms: Global.Symbol*): Boolean

     Definition Classes
       TypeDiagnostics

136. #### def noErroneousTrees(trees: Global.Tree*): Boolean

     Definition Classes
       TypeDiagnostics

137. #### def noErroneousTypes(tps: Global.Type*): Boolean

     The common situation of making sure nothing is erroneous could be nicer if Symbols, Types, and Trees all implemented some common interface in which isErroneous and similar would be placed.

     The common situation of making sure nothing is erroneous could be nicer if Symbols, Types, and Trees all implemented some common interface in which isErroneous and similar would be placed.

     Definition Classes
       TypeDiagnostics

138. #### def normalize(tp: Global.Type): Global.Type

     Automatically perform the following conversions on expression types: A method type becomes the corresponding function type.

     Automatically perform the following conversions on expression types: A method type becomes the corresponding function type. A nullary method type becomes its result type. Implicit parameters are skipped. This method seems to be performance critical.

     Definition Classes
       Infer

139. #### def notAnyRefMessage(found: Global.Type): String

     Definition Classes
       ContextErrors

140. #### final def notify(): Unit

     Definition Classes
       AnyRef

141. #### final def notifyAll(): Unit

     Definition Classes
       AnyRef

142. #### def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit

     Definition Classes
       Macros

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

     Definition Classes
       Macros

144. #### final def onlyStickyModes(mode: Int): Int

     Definition Classes
       Modes

145. #### def openMacros: collection.immutable.List[reflect.macros.runtime.Context { val universe: Analyzer.this.global.type }]

     Definition Classes
       Macros

146. #### object packageObjects extends SubComponent

147. #### def pluginsPt(pt: Global.Type, typer: Typer, tree: Global.Tree, mode: Int): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsPt

148. #### def pluginsTypeSig(tpe: Global.Type, typer: Typer, defTree: Global.Tree, pt: Global.Type): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSig

149. #### def pluginsTypeSigAccessor(tpe: Global.Type, typer: Typer, tree: Global.ValDef, sym: Global.Symbol): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypeSigAccessor

150. #### def pluginsTyped(tpe: Global.Type, typer: Typer, tree: Global.Tree, mode: Int, pt: Global.Type): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTyped

151. #### def pluginsTypedReturn(tpe: Global.Type, typer: Typer, tree: Global.Return, pt: Global.Type): Global.Type

     Definition Classes
       AnalyzerPlugins
     See also

       AnalyzerPlugin.pluginsTypedReturn

152. #### 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

153. #### 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

154. #### 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, positional args don't appear after named ones.

     Definition Classes
       NamesDefaults

155. #### 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

156. #### def reorderArgsInv[T](args: List[T], pos: (Int) ⇒ Int)(implicit arg0: ClassTag[T]): List[T]

     pos

       maps indices from new to old (!)

     Definition Classes
       NamesDefaults

157. #### def resetContexts(): Unit

     Definition Classes
       Contexts

158. #### def resetImplicits(): Unit

     Definition Classes
       Implicits

159. #### def resetTyper(): Unit

     Definition Classes
       Typers

160. #### def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit

     Definition Classes
       TypeDiagnostics

161. #### def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String): 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

162. #### def rootContext(unit: Global.CompilationUnit, tree: Global.Tree, erasedTypes: Boolean): Context

     Definition Classes
       Contexts

163. #### def rootContext(unit: Global.CompilationUnit, tree: Global.Tree): Context

     Definition Classes
       Contexts

164. #### def rootContext(unit: Global.CompilationUnit): Context

     Definition Classes
       Contexts

165. #### 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. Typically that is `java.lang`, `scala`, and scala.Predef, in that order. Exceptions:

     - if option `-Yno-imports` is given, nothing is imported
     - if the unit is java defined, only `java.lang` is imported
     - if option `-Yno-predef` is given, if the unit body has an import of Predef among its leading imports, or if the tree is scala.Predef, `Predef` is not imported.
     Attributes
       protected
     Definition Classes
       Contexts

166. #### def setAddendum(pos: Global.Position, msg: () ⇒ String): Unit

     Definition Classes
       TypeDiagnostics

167. #### final val shortenImports: Boolean(false)

     Definition Classes
       Typers

168. #### def skipImplicit(tp: Global.Type): Global.Type

     Definition Classes
       Infer

169. #### def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], variances: List[Int], upper: Boolean, depth: Int): 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`

     variances

       The variances of type parameters; need to reverse solution direction for all contravariant variables.

     upper

       When `true` search for max solution else min.

     Definition Classes
       Infer
     Exceptions thrown
       NoInstance

170. #### final def synchronized[T0](arg0: ⇒ T0): T0

     Definition Classes
       AnyRef

171. #### object synthesisUtil

     Definition Classes
       MethodSynthesis

172. #### def toString(): String

     Definition Classes
       AnyRef → Any

173. #### def transformNamedApplication(typer: Typer, mode: Int, pt: Global.Type)(tree: Global.Tree, argPos: (Int) ⇒ Int): Global.Tree

     Transform a function application into a Block, and assigns typer.

     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

     returns

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

     Definition Classes
       NamesDefaults

174. #### val transformed: HashMap[Global.Tree, Global.Tree]

     Definition Classes
       Typers

175. #### def treeSymTypeMsg(tree: Global.Tree): String

     Definition Classes
       TypeDiagnostics

176. #### def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String

     Definition Classes
       TypeDiagnostics

177. #### 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, 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, and that that method is signature-wise compatible with the given macro definition.

     returns

       Typechecked rhs of the given macro definition if everything is okay. EmptyTree if an error occurs.

     Definition Classes
       Macros

178. #### object typerFactory extends SubComponent

179. #### 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

180. #### def unapplyMember(tp: Global.Type): Global.Symbol

     returns unapply or unapplySeq if available

     returns unapply or unapplySeq if available

     Definition Classes
       Unapplies

181. #### def unapplyParameterType(extractor: Global.Symbol): Global.Symbol

     returns unapply member's parameter type.

     returns unapply member's parameter type.

     Definition Classes
       Unapplies

182. #### def unapplyReturnTypeExpected(argsLength: Int): Global.Type

     returns type of the unapply method returning T_0.

     returns type of the unapply method returning T_0...T_n for n == 0, boolean for n == 1, Some[T0] else Some[Product[Ti]]

     Definition Classes
       Unapplies

183. #### def unapplyTypeList(pos: Global.Position, ufn: Global.Symbol, ufntpe: Global.Type, args: List[Global.Tree]): List[Global.Type]

     returns type list for return type of the extraction

     returns type list for return type of the extraction

     Definition Classes
       Unapplies
     See also

       extractorFormalTypes

184. #### 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.

     Definition Classes
       TypeDiagnostics

185. #### def varianceInArgs(tps: List[Global.Type], tparams1: List[Global.Symbol])(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in all type arguments `tps` which correspond to formal type parameters `tparams1`.

     Compute variance of type parameter `tparam` in all type arguments `tps` which correspond to formal type parameters `tparams1`.

     Definition Classes
       Variances

186. #### def varianceInAttrib(annot: Global.AnnotationInfo)(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in type annotation `annot`.

     Compute variance of type parameter `tparam` in type annotation `annot`.

     Definition Classes
       Variances

187. #### def varianceInAttribs(annots: List[Global.AnnotationInfo])(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in all type annotations `annots`.

     Compute variance of type parameter `tparam` in all type annotations `annots`.

     Definition Classes
       Variances

188. #### def varianceInSym(sym: Global.Symbol)(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in type of symbol `sym`.

     Compute variance of type parameter `tparam` in type of symbol `sym`.

     Definition Classes
       Variances

189. #### def varianceInSyms(syms: List[Global.Symbol])(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in types of all symbols `sym`.

     Compute variance of type parameter `tparam` in types of all symbols `sym`.

     Definition Classes
       Variances

190. #### def varianceInType(tp: Global.Type)(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in type `tp`.

     Compute variance of type parameter `tparam` in type `tp`.

     Definition Classes
       Variances

191. #### def varianceInTypes(tps: List[Global.Type])(tparam: Global.Symbol): Int

     Compute variance of type parameter `tparam` in all types `tps`.

     Compute variance of type parameter `tparam` in all types `tps`.

     Definition Classes
       Variances

192. #### def varianceWord(sym: Global.Symbol): String

     Definition Classes
       TypeDiagnostics

193. #### final def wait(): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

194. #### final def wait(arg0: Long, arg1: Int): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

195. #### final def wait(arg0: Long): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

196. #### def withAddendum(pos: Global.Position): (String) ⇒ String

     Definition Classes
       TypeDiagnostics

197. #### 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

198. #### def →[B](y: B): (Analyzer, B)

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

### Shadowed Implicit Value Members

1. #### val self: Any

   Implicit information
     This member is added by an implicit conversion from Analyzer to StringAdd performed by method any2stringadd in scala.Predef.
   Shadowing
     This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
     To access this member you can use a type ascription:

         (analyzer: StringAdd).self

   Definition Classes
     StringAdd

2. #### val self: Any

   Implicit information
     This member is added by an implicit conversion from Analyzer to StringFormat performed by method any2stringfmt in scala.Predef.
   Shadowing
     This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
     To access this member you can use a type ascription:

         (analyzer: StringFormat).self

   Definition Classes
     StringFormat

### Deprecated Value Members

1. #### def companionClassOf(module: Global.Symbol, ctx: Context): Global.Symbol

   Definition Classes
     Namers
   Annotations
     @deprecated
   Deprecated

     (Since version 2.10.0) Use `companionSymbolOf` instead

2. #### def companionModuleOf(clazz: Global.Symbol, ctx: Context): Global.Symbol

   Definition Classes
     Namers
   Annotations
     @deprecated
   Deprecated

     (Since version 2.10.0) Use `companionSymbolOf` instead

3. #### def underlying(member: Global.Symbol): Global.Symbol

   Definition Classes
     Namers
   Annotations
     @deprecated
   Deprecated

     (Since version 2.10.0) Use underlyingSymbol instead

4. #### def x: Analyzer

   Implicit information
     This member is added by an implicit conversion from Analyzer to ArrowAssoc[Analyzer] performed by method any2ArrowAssoc in scala.Predef.
   Shadowing
     This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
     To access this member you can use a type ascription:

         (analyzer: ArrowAssoc[Analyzer]).x

   Definition Classes
     ArrowAssoc
   Annotations
     @deprecated
   Deprecated

     (Since version 2.10.0) Use `leftOfArrow`instead``

5. #### def x: Analyzer

   Implicit information
     This member is added by an implicit conversion from Analyzer to Ensuring[Analyzer] performed by method any2Ensuring in scala.Predef.
   Shadowing
     This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
     To access this member you can use a type ascription:

         (analyzer: Ensuring[Analyzer]).x

   Definition Classes
     Ensuring
   Annotations
     @deprecated
   Deprecated

     (Since version 2.10.0) Use `resultOfEnsuring`instead``

### Inherited from AnalyzerPlugins

### Inherited from StdAttachments

### Inherited from ContextErrors

### Inherited from TypeDiagnostics

### Inherited from NamesDefaults

### Inherited from Macros

### Inherited from Traces

### Inherited from FastTrack

### Inherited from Unapplies

### Inherited from SyntheticMethods

### Inherited from TreeDSL

### Inherited from EtaExpansion

### Inherited from Variances

### Inherited from Implicits

### Inherited from Infer

### Inherited from Checkable

### Inherited from Typers

### Inherited from Tags

### Inherited from Adaptations

### Inherited from Modes

### Inherited from Namers

### Inherited from MethodSynthesis

### Inherited from Contexts

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from Analyzer to StringAdd

### Inherited by implicit conversion any2stringfmt from Analyzer to StringFormat

### Inherited by implicit conversion any2ArrowAssoc from Analyzer to ArrowAssoc[Analyzer]

### Inherited by implicit conversion any2Ensuring from Analyzer to Ensuring[Analyzer]

### Ungrouped