scala.tools.nsc.typechecker.Typers

# Typer

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

Linear Supertypes
Analyzer.TyperContextErrors, Analyzer.Tag, Analyzer.Adaptation, Analyzer.TyperDiagnostics, AnyRef, Any
Known Subclasses
BodyDuplicator, BodyDuplicator, Eraser, ImplicitSearch, TreeChecker, typer
Type Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Typer
2. TyperContextErrors
3. Tag
4. Adaptation
5. TyperDiagnostics
6. AnyRef
7. Any

Implicitly

1. by any2stringadd
2. by any2stringfmt
3. by any2ArrowAssoc
4. by any2Ensuring

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Instance Constructors

1. #### new Typer(context0: Analyzer.Context)

### 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.Typer to StringAdd performed by method any2stringadd in scala.Predef.
   Definition Classes
     StringAdd

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

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

   Definition Classes
     TyperContextErrors

9. #### def adapt(tree: Global.Tree, mode: Int, pt: Global.Type, original: Global.Tree = EmptyTree): Global.Tree

   Perform the following adaptations of expression, pattern or type `tree` wrt to given mode `mode` and given prototype `pt`: (-1) For expressions with annotated types, let AnnotationCheckers decide what to do (0) Convert expressions with constant types to literals (unless in interactive/scaladoc mode) (1) Resolve overloading, unless mode contains FUNmode (2) Apply parameterless functions (3) Apply polymorphic types to fresh instances of their type parameters and store these instances in context.

   Perform the following adaptations of expression, pattern or type `tree` wrt to given mode `mode` and given prototype `pt`: (-1) For expressions with annotated types, let AnnotationCheckers decide what to do (0) Convert expressions with constant types to literals (unless in interactive/scaladoc mode) (1) Resolve overloading, unless mode contains FUNmode (2) Apply parameterless functions (3) Apply polymorphic types to fresh instances of their type parameters and store these instances in context.undetparams, unless followed by explicit type application. (4) Do the following to unapplied methods used as values: (4.1) If the method has only implicit parameters pass implicit arguments (4.2) otherwise, if `pt` is a function type and method is not a constructor, convert to function by eta-expansion, (4.3) otherwise, if the method is nullary with a result type compatible to `pt` and it is not a constructor, apply it to () otherwise issue an error (5) Convert constructors in a pattern as follows: (5.1) If constructor refers to a case class factory, set tree's type to the unique instance of its primary constructor that is a subtype of the expected type. (5.2) If constructor refers to an extractor, convert to application of unapply or unapplySeq method.

   (6) Convert all other types to TypeTree nodes. (7) When in TYPEmode but not FUNmode or HKmode, check that types are fully parameterized (7.1) In HKmode, higher-kinded types are allowed, but they must have the expected kind-arity (8) When in both EXPRmode and FUNmode, add apply method calls to values of object type. (9) If there are undetermined type variables and not POLYmode, infer expression instance Then, if tree's type is not a subtype of expected type, try the following adaptations: (10) If the expected type is Byte, Short or Char, and the expression is an integer fitting in the range of that type, convert it to that type. (11) Widen numeric literals to their expected type, if necessary (12) When in mode EXPRmode, convert E to { E; () } if expected type is scala.Unit. (13) When in mode EXPRmode, apply AnnotationChecker conversion if expected type is annotated. (14) When in mode EXPRmode, apply a view If all this fails, error

   Attributes
     protected

10. #### def adaptCase(cdef: Global.CaseDef, mode: Int, tpe: Global.Type): Global.CaseDef

11. #### def adaptToArguments(qual: Global.Tree, name: Global.Name, args: List[Global.Tree], pt: Global.Type, reportAmbiguous: Boolean, saveErrors: Boolean): Global.Tree

    Try to apply an implicit conversion to `qual` to that it contains a method `name` which can be applied to arguments `args` with expected type `pt`.

    Try to apply an implicit conversion to `qual` to that it contains a method `name` which can be applied to arguments `args` with expected type `pt`. If `pt` is defined, there is a fallback to try again with pt = ?. This helps avoiding propagating result information too far and solves #1756. If no conversion is found, return `qual` unchanged.

12. #### def adaptToMember(qual: Global.Tree, searchTemplate: Global.Type, reportAmbiguous: Boolean = true, saveErrors: Boolean = true): Global.Tree

13. #### def adaptToMemberWithArgs(tree: Global.Tree, qual: Global.Tree, name: Global.Name, mode: Int, reportAmbiguous: Boolean, saveErrors: Boolean): Global.Tree

    Try to apply an implicit conversion to `qual` so that it contains a method `name`.

    Try to apply an implicit conversion to `qual` so that it contains a method `name`. If that's ambiguous try taking arguments into account using `adaptToArguments`.

14. #### def adaptToName(qual: Global.Tree, name: Global.Name): Global.Tree

    Try to apply an implicit conversion to `qual` to that it contains a member `name` of arbitrary type.

    Try to apply an implicit conversion to `qual` to that it contains a member `name` of arbitrary type. If no conversion is found, return `qual` unchanged.

15. #### def applyImplicitArgs(fun: Global.Tree): Global.Tree

    Find implicit arguments and pass them to given tree.

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

    Definition Classes
      Any

17. #### def atOwner(tree: Global.Tree, owner: Global.Symbol): Analyzer.Typer

18. #### def atOwner(owner: Global.Symbol): Analyzer.Typer

19. #### def callToCompanionConstr(context: Analyzer.Context, calledFun: Global.Symbol): Boolean

20. #### def checkClassType(tpt: Global.Tree): Boolean

    Check that `tpt` refers to a non-refinement class type

21. #### object checkDead

    Definition Classes
      TyperDiagnostics

22. #### def checkExistentialsFeature(pos: Global.Position, tpe: Global.Type, prefix: String): AnyVal

23. #### def checkFeature(pos: Global.Position, featureTrait: Global.Symbol, construct: ⇒ String = "", immediate: Boolean = false): Boolean

    Check whether feature given by `featureTrait` is enabled.

    Check whether feature given by `featureTrait` is enabled. If it is not, issue an error or a warning depending on whether the feature is required.

    construct

      A string expression that is substituted for "#" in the feature description string

    immediate

      When set, feature check is run immediately, otherwise it is run at the end of the typechecking run for the enclosing unit. This is done to avoid potential cyclic reference errors by implicits that are forced too early.

    returns

      if feature check is run immediately: true if feature is enabled, false otherwise if feature check is delayed or suppressed because we are past typer: true

24. #### def checkFinitary(classinfo: Global.ClassInfoType): Unit

25. #### def checkMethodStructuralCompatible(ddef: Global.DefDef): Unit

    Check if a structurally defined method violates implementation restrictions.

    Check if a structurally defined method violates implementation restrictions. A method cannot be called if it is a non-private member of a refinement type and if its parameter's types are any of:

    - the self-type of the refinement
    - a type member of the refinement
    - an abstract type declared outside of the refinement.
    - an instance of a value class Furthermore, the result type may not be a value class either

26. #### object checkNoEscaping extends Global.TypeMap

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

27. #### def checkNonCyclic(defn: Global.Tree, tpt: Global.Tree): Unit

28. #### def checkNonCyclic(sym: Global.Symbol): Unit

29. #### def checkNonCyclic(pos: Global.Position, tp: Global.Type, lockedSym: Global.Symbol): Boolean

30. #### def checkNonCyclic(pos: Global.Position, tp: Global.Type): Boolean

    Check that type `tp` is not a subtype of itself.

    Check that type `tp` is not a subtype of itself.

    pos

      ...

    tp

      ...

    returns

      `true` if `tp` is not a subtype of itself.

31. #### def checkParamsConvertible(tree: Global.Tree, tpe0: Global.Type): Unit

32. #### def checkStable(tree: Global.Tree): Global.Tree

    Check that `tree` is a stable expression.

    Check that `tree` is a stable expression.

    tree

      ...

    returns

      ...

33. #### def checkStablePrefixClassType(tpt: Global.Tree): Boolean

    Check that `tpt` refers to a class type with a stable prefix.

34. #### def checkValidAdaptation(t: Global.Tree, args: List[Global.Tree]): Boolean

    Definition Classes
      Adaptation

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

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

36. #### def computeMacroDefType(tree: Global.Tree, pt: Global.Type): Global.Type

37. #### def computeParamAliases(clazz: Global.Symbol, vparamss: List[List[Global.ValDef]], rhs: Global.Tree): Unit

    Enter all aliases of local parameter accessors.

    Enter all aliases of local parameter accessors.

    clazz

      ...

    vparamss

      ...

    rhs

      ...

38. #### def computeType(tree: Global.Tree, pt: Global.Type): Global.Type

39. #### final def constrTyperIf(inConstr: Boolean): Analyzer.Typer

    The typer for an expression, depending on where we are.

    The typer for an expression, depending on where we are. If we are before a superclass call, this is a typer over a constructor context; otherwise it is the current typer.

40. #### var context: Analyzer.Context

41. #### def context1: Analyzer.Context

42. #### def cyclicReferenceMessage(sym: Global.Symbol, tree: Global.Tree): Option[String]

    Returns Some(msg) if the given tree is untyped apparently due to a cyclic reference, and None otherwise.

    Returns Some(msg) if the given tree is untyped apparently due to a cyclic reference, and None otherwise.

    Definition Classes
      TyperDiagnostics

43. #### final def deindentTyping(): Unit

44. #### object deskolemizeGADTSkolems extends Global.TypeMap

45. #### def doTypedApply(tree: Global.Tree, fun0: Global.Tree, args: List[Global.Tree], mode: Int, pt: Global.Type): Global.Tree

46. #### def doTypedUnapply(tree: Global.Tree, fun0: Global.Tree, fun: Global.Tree, args: List[Global.Tree], mode: Int, pt: Global.Type): Global.Tree

47. #### def dropExistential(tp: Global.Type): Global.Type

48. #### object dyna

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

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

50. #### def ensuring(cond: (Analyzer.Typer) ⇒ Boolean): Analyzer.Typer

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

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

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

52. #### def ensuring(cond: Boolean): Analyzer.Typer

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

53. #### def enterSym(txt: Analyzer.Context, tree: Global.Tree): Analyzer.Context

    Attributes
      protected

54. #### def enterSyms(txt: Analyzer.Context, trees: List[Global.Tree]): Unit

    Attributes
      protected

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

    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

57. #### def extractorForUncheckedType(pos: Global.Position, pt: Global.Type): Option[Global.Tree]

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

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

59. #### def finishMethodSynthesis(templ: Global.Template, clazz: Global.Symbol, context: Analyzer.Context): Global.Template

    In order to override this in the TreeCheckers Typer so synthetics aren't re-added all the time, it is exposed here the module/class typing methods go through it.

    In order to override this in the TreeCheckers Typer so synthetics aren't re-added all the time, it is exposed here the module/class typing methods go through it. ...but it turns out it's also the ideal spot for namer/typer coordination for the tricky method synthesis scenarios, so we'll make it that.

    Attributes
      protected

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

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

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

    Definition Classes
      AnyRef → Any

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

    Definition Classes
      AnyRef → Any

63. #### final def indentTyping(): Unit

64. #### val infer: Analyzer.Inferencer

65. #### def inferView(tree: Global.Tree, from: Global.Type, to: Global.Type, reportAmbiguous: Boolean, saveErrors: Boolean): Global.Tree

    Infer an implicit conversion (``view) between two types.``

    Infer an implicit conversion (``view) between two types.``

    tree

      The tree which needs to be converted.

    from

      The source type of the conversion

    to

      The target type of the conversion

    reportAmbiguous

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

    saveErrors

      Should ambiguous and divergent implicit errors that were buffered during the inference of a view be put into the original buffer. False iff we don't care about them.

66. #### def inferView(tree: Global.Tree, from: Global.Type, to: Global.Type, reportAmbiguous: Boolean): Global.Tree

67. #### def instantiate(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

68. #### def instantiateExpectingUnit(tree: Global.Tree, mode: Int): Global.Tree

    If the expected type is Unit: try instantiating type arguments with expected type Unit, but if that fails, try again with pt = WildcardType and discard the expression.

69. #### def instantiatePossiblyExpectingUnit(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

70. #### def isCapturedExistential(sym: Global.Symbol): Boolean

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

    Definition Classes
      Any

72. #### def isNamedApplyBlock(tree: Global.Tree): Boolean

    Is `tree` a block created by a named application?

73. #### def isReferencedFrom(ctx: Analyzer.Context, sym: Global.Symbol): Boolean

74. #### def isStableExceptVolatile(tree: Global.Tree): Boolean

    Would tree be a stable (i.

    Would tree be a stable (i.e. a pure expression) if the type of its symbol was not volatile?

    Attributes
      protected

75. #### def isStale(sym: Global.Symbol): Boolean

    A symbol is stale if it is toplevel, to be loaded from a classfile, and the classfile is produced from a sourcefile which is compiled in the current run.

76. #### def labelTyper(ldef: Global.LabelDef): Analyzer.Typer

    The typer for a label definition.

    The typer for a label definition. If this is part of a template we first have to enter the label definition.

77. #### def member(qual: Global.Tree, name: Global.Name): Global.Symbol

    The member with given name of given qualifier tree

78. #### def namer: Analyzer.Namer

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

    Definition Classes
      AnyRef

80. #### def needsInstantiation(tparams: List[Global.Symbol], formals: List[Global.Type], args: List[Global.Tree]): Boolean

    Does function need to be instantiated, because a missing parameter in an argument closure overlaps with an uninstantiated formal?

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

    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef

83. #### def packCaptured(tpe: Global.Type): Global.Type

84. #### def packSymbols(hidden: List[Global.Symbol], tp: Global.Type): Global.Type

    Compute an existential type from raw hidden symbols `syms` and type `tp`

85. #### def packedType(tree: Global.Tree, owner: Global.Symbol): Global.Type

    convert local symbols and skolems to existentials

86. #### def parentTypes(templ: Global.Template): List[Global.Tree]

87. #### def permanentlyHiddenWarning(pos: Global.Position, hidden: Global.Name, defn: Global.Symbol): Unit

    Definition Classes
      TyperDiagnostics

88. #### final def printInference(s: ⇒ String): Unit

    Annotations
      @inline()

89. #### final def printTyping(s: ⇒ String): Unit

    Annotations
      @inline()

90. #### def ptOrLub(tps: List[Global.Type], pt: Global.Type): (Global.Type, Boolean)

91. #### def ptOrLubPacked(trees: List[Global.Tree], pt: Global.Type): (Global.Type, Boolean)

92. #### def qualifyingClass(tree: Global.Tree, qual: Global.Name, packageOK: Boolean): Global.Symbol

    The qualifying class of a this or super with prefix `qual`.

    The qualifying class of a this or super with prefix `qual`. packageOk is equal false when qualifying class symbol

93. #### def reallyExists(sym: Global.Symbol): Boolean

    Is symbol defined and not stale?

94. #### def reenterTypeParams(tparams: List[Global.TypeDef]): List[Global.Symbol]

95. #### def reenterValueParams(vparamss: List[List[Global.ValDef]]): Unit

96. #### def reportTypeError(context0: Analyzer.Context, pos: Global.Position, ex: Global.TypeError): Unit

    Report a type error.

    Report a type error.

    ex

      The exception that caused the error

    Definition Classes
      TyperDiagnostics

97. #### def resolveClassTag(pos: Global.Position, tp: Global.Type, allowMaterialization: Boolean = true): Global.Tree

    Finds in scope or materializes a ClassTag.

    Finds in scope or materializes a ClassTag. Should be used instead of ClassManifest every time compiler needs to persist an erasure.

    Once upon a time, we had an `ErasureTag` which was to `ClassTag` the same that `WeakTypeTag` is for `TypeTag`. However we found out that we don't really need this concept, so it got removed.

    pos

      Position for error reporting. Please, provide meaningful value.

    tp

      Type we're looking a ClassTag for, e.g. resolveClassTag(pos, IntClass.tpe) will look for ClassTag[Int].

    allowMaterialization

      If true (default) then the resolver is allowed to launch materialization macros when there's no class tag in scope. If false then materialization macros are prohibited from running.

    Definition Classes
      Tag

98. #### def resolveTypeTag(pos: Global.Position, pre: Global.Type, tp: Global.Type, concrete: Boolean, allowMaterialization: Boolean = true): Global.Tree

    Finds in scope or materializes an WeakTypeTag (if `concrete` is false) or a TypeTag (if `concrete` is true).

    Finds in scope or materializes an WeakTypeTag (if `concrete` is false) or a TypeTag (if `concrete` is true).

    pos

      Position for error reporting. Please, provide meaningful value.

    pre

      Prefix that represents a universe this type tag will be bound to. If `pre` is set to `NoType`, then any type tag in scope will do, regardless of its affiliation. If `pre` is set to `NoType`, and tag resolution involves materialization, then `mkRuntimeUniverseRef` will be used.

    tp

      Type we're looking a TypeTag for, e.g. resolveTypeTag(pos, mkRuntimeUniverseRef, IntClass.tpe, false) will look for scala.reflect.runtime.universe.TypeTag[Int].

    concrete

      If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. If false then the function will always succeed (abstract types will be reified as free types).

    allowMaterialization

      If true (default) then the resolver is allowed to launch materialization macros when there's no type tag in scope. If false then materialization macros are prohibited from running.

    Definition Classes
      Tag

99. #### def rewrappingWrapperTrees(f: (Global.Tree) ⇒ List[Global.Tree]): (Global.Tree) ⇒ List[Global.Tree]

    For flatMapping a list of trees when you want the DocDefs and Annotated to be transparent.

100. #### def silent[T](op: (Analyzer.Typer) ⇒ T, reportAmbiguousErrors: Boolean = context.ambiguousErrors, newtree: Global.Tree = context.tree): Analyzer.SilentResult[T]

101. #### def stabilizeFun(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

     tree

       ...

     mode

       ...

     pt

       ...

     returns

       ...

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

     Definition Classes
       AnyRef

103. #### def synthesizePartialFunction(paramName: Global.TermName, paramPos: Global.Position, tree: Global.Tree, mode: Int, pt0: Global.Type): Global.Tree

     synthesize and type check a PartialFunction implementation based on the match in `tree`

     synthesize and type check a PartialFunction implementation based on the match in `tree`

     `param => sel match { cases }` becomes:

     new AbstractPartialFunction[$argTp, $matchResTp] { def applyOrElse[A1 <: $argTp, B1 >: $matchResTp]($param: A1, default: A1 => B1): B1 = $selector match { $cases } def isDefinedAt(x: $argTp): Boolean = $selector match { $casesTrue } }

     TODO: it would be nicer to generate the tree specified above at once and type it as a whole, there are two gotchas:

     - matchResTp may not be known until we've typed the match (can only use resTp when it's fully defined),
       - if we typed the match in isolation first, you'd know its result type, but would have to re-jig the owner structure
       - could we use a type variable for matchResTp and backpatch it?
     - occurrences of `this` in `cases` or `sel` must resolve to the this of the class originally enclosing the match, not of the anonymous partial function subclass

     an alternative TODO: add partial function AST node or equivalent and get rid of this synthesis --> do everything in uncurry (or later) however, note that pattern matching codegen is designed to run *before* uncurry

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

     Definition Classes
       AnyRef → Any

105. #### def transformedOr(tree: Global.Tree, op: ⇒ Global.Tree): Global.Tree

106. #### def transformedOrTyped(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

107. #### def typed(tree: Global.Tree, pt: Global.Type): Global.Tree

     Types expression `tree` with given prototype `pt`.

     Types expression `tree` with given prototype `pt`.

     tree

       ...

     pt

       ...

     returns

       ...

108. #### def typed(tree: Global.Tree): Global.Tree

     Types expression or definition `tree`.

     Types expression or definition `tree`.

     tree

       ...

     returns

       ...

109. #### def typed(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

     tree

       ...

     mode

       ...

     pt

       ...

     returns

       ...

110. #### def typed1(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

111. #### def typedAnnotation(ann: Global.Tree, mode: Int = EXPRmode, selfsym: Global.Symbol = NoSymbol, annClass: Global.Symbol = AnnotationClass, requireJava: Boolean = false): Global.AnnotationInfo

     Convert an annotation constructor call into an AnnotationInfo.

     Convert an annotation constructor call into an AnnotationInfo.

     annClass

       the expected annotation class

112. #### def typedArg(arg: Global.Tree, mode: Int, newmode: Int, pt: Global.Type): Global.Tree

113. #### def typedArgs(args0: List[Global.Tree], mode: Int, formals0: List[Global.Type], adapted0: List[Global.Type]): List[Global.Tree]

     Type trees in `args0` against corresponding expected type in `adapted0`.

     Type trees in `args0` against corresponding expected type in `adapted0`.

     The mode in which each argument is typed is derived from `mode` and whether the arg was originally by-name or var-arg (need `formals0` for that) the default is by-val, of course.

     (docs reverse-engineered -- AM)

114. #### def typedArgs(args: List[Global.Tree], mode: Int): collection.immutable.List[Global.Tree]

115. #### def typedBlock(block: Global.Block, mode: Int, pt: Global.Type): Global.Block

     block

       ...

     mode

       ...

     pt

       ...

     returns

       ...

116. #### def typedCase(cdef: Global.CaseDef, pattpe: Global.Type, pt: Global.Type): Global.CaseDef

     cdef

       ...

     pattpe

       ...

     pt

       ...

     returns

       ...

117. #### def typedCases(cases: List[Global.CaseDef], pattp: Global.Type, pt: Global.Type): List[Global.CaseDef]

118. #### def typedClassDef(cdef: Global.ClassDef): Global.Tree

     cdef

       ...

     returns

       ...

119. #### def typedClassOf(tree: Global.Tree, tpt: Global.Tree, noGen: Boolean = false): Global.Tree

120. #### def typedDefDef(ddef: Global.DefDef): Global.DefDef

     ddef

       ...

     returns

       ...

121. #### def typedExistentialTypeTree(tree: Global.ExistentialTypeTree, mode: Int): Global.Tree

     Attributes
       protected

122. #### def typedHigherKindedType(tree: Global.Tree): Global.Tree

123. #### def typedHigherKindedType(tree: Global.Tree, mode: Int): Global.Tree

124. #### def typedHigherKindedType(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

     Types a higher-kinded type tree -- pt denotes the expected kind

125. #### def typedImport(imp: Global.Import): Global.Import

126. #### def typedLabelDef(ldef: Global.LabelDef): Global.LabelDef

127. #### def typedMatch(selector: Global.Tree, cases: List[Global.CaseDef], mode: Int, pt: Global.Type, tree: Global.Tree = EmptyTree): Global.Match

128. #### def typedModifiers(mods: Global.Modifiers): Global.Modifiers

     Remove definition annotations from modifiers (they have been saved into the symbol's ``annotations in the type completer / namer)``

     Remove definition annotations from modifiers (they have been saved into the symbol's ``annotations in the type completer / namer)``

     However reification does need annotation definitions to proceed. Unfortunately, AnnotationInfo doesn't provide enough info to reify it in general case. The biggest problem is with the "atp: Type" field, which cannot be reified in some situations that involve locally defined annotations. See more about that in Reifiers.scala.

     That's why the original tree gets saved into ``original field of AnnotationInfo (happens elsewhere). The field doesn't get pickled/unpickled and exists only during a single compilation run. This simultaneously allows us to reify annotations and to preserve backward compatibility.``

129. #### def typedModuleDef(mdef: Global.ModuleDef): Global.Tree

     mdef

       ...

     returns

       ...

130. #### def typedOperator(tree: Global.Tree): Global.Tree

     Types function part of an application

131. #### def typedPattern(tree: Global.Tree, pt: Global.Type): Global.Tree

     Types a pattern with prototype `pt`

     Types a pattern with prototype `pt`

132. #### def typedPos(pos: Global.Position)(tree: Global.Tree): Global.Tree

133. #### def typedPos(pos: Global.Position, mode: Int, pt: Global.Type)(tree: Global.Tree): Global.Tree

134. #### def typedQualifier(tree: Global.Tree): Global.Tree

135. #### def typedQualifier(tree: Global.Tree, mode: Int): Global.Tree

     Types qualifier `tree` of a select node.

     Types qualifier `tree` of a select node. E.g. is tree occurs in a context like `tree.m`.

136. #### def typedQualifier(tree: Global.Tree, mode: Int, pt: Global.Type): Global.Tree

     Types qualifier `tree` of a select node.

     Types qualifier `tree` of a select node. E.g. is tree occurs in a context like `tree.m`.

137. #### def typedRefinement(templ: Global.Template): Unit

138. #### def typedStats(stats: List[Global.Tree], exprOwner: Global.Symbol): List[Global.Tree]

139. #### def typedTemplate(templ: Global.Template, parents1: List[Global.Tree]): Global.Template

     templ

       ...

     parents1

       ...

       - Check that inner classes do not inherit from Annotation

     returns

       ...

140. #### def typedType(tree: Global.Tree): Global.Tree

     Types a (fully parameterized) type tree

141. #### def typedType(tree: Global.Tree, mode: Int): Global.Tree

     Types a (fully parameterized) type tree

142. #### def typedTypeApply(tree: Global.Tree, mode: Int, fun: Global.Tree, args: List[Global.Tree]): Global.Tree

     Attributes
       protected

143. #### def typedTypeConstructor(tree: Global.Tree): Global.Tree

144. #### def typedTypeConstructor(tree: Global.Tree, mode: Int): Global.Tree

     Types a type constructor tree used in a new or supertype

145. #### def typedTypeDef(tdef: Global.TypeDef): Global.TypeDef

146. #### def typedUseCase(useCase: Global.UseCase): Unit

147. #### def typedValDef(vdef: Global.ValDef): Global.ValDef

     vdef

       ...

     returns

       ...

148. #### final def typerReportAnyContextErrors[T](c: Analyzer.Context)(f: (Analyzer.Typer) ⇒ T): T

     Annotations
       @inline()

149. #### final def typerWithCondLocalContext[T](c: ⇒ Analyzer.Context)(cond: Boolean)(f: (Analyzer.Typer) ⇒ T): T

     Annotations
       @inline()

150. #### final def typerWithLocalContext[T](c: Analyzer.Context)(f: (Analyzer.Typer) ⇒ T): T

     Annotations
       @inline()

151. #### def validateParentClasses(parents: List[Global.Tree], selfType: Global.Type): Unit

     Check that

     Check that

     - all parents are class types,
     - first parent class is not a mixin; following classes are mixins,
     - final classes are not inherited,

     - sealed classes are only inherited by classes which are nested within definition of base class, or that occur within same statement sequence,

     - self-type of current class is a subtype of self-type of each parent class.
     - no two parents define same symbol.

152. #### def virtualizedMatch(match_: Global.Match, mode: Int, pt: Global.Type): Global.Tree

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

156. #### final def withCondConstrTyper[T](inConstr: Boolean)(f: (Analyzer.Typer) ⇒ T): T

     Annotations
       @inline()

157. #### final def withSavedContext[T](c: Analyzer.Context)(f: ⇒ T): T

     Annotations
       @inline()

158. #### def wrapClassTagUnapply(uncheckedPattern: Global.Tree, classTagExtractor: Global.Tree, pt: Global.Type): Global.Tree

159. #### final val xtypes: Boolean(false)

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

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

         (typer: StringAdd).self

   Definition Classes
     StringAdd

2. #### val self: Any

   Implicit information
     This member is added by an implicit conversion from Analyzer.Typer 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:

         (typer: StringFormat).self

   Definition Classes
     StringFormat

### Deprecated Value Members

1. #### def x: Analyzer.Typer

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

         (typer: ArrowAssoc[Analyzer.Typer]).x

   Definition Classes
     ArrowAssoc
   Annotations
     @deprecated
   Deprecated

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

2. #### def x: Analyzer.Typer

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

         (typer: Ensuring[Analyzer.Typer]).x

   Definition Classes
     Ensuring
   Annotations
     @deprecated
   Deprecated

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

### Inherited from Analyzer.TyperContextErrors

### Inherited from Analyzer.Tag

### Inherited from Analyzer.Adaptation

### Inherited from Analyzer.TyperDiagnostics

### Inherited from AnyRef

### Inherited from Any

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

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

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

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

### Ungrouped