scala.tools.nsc.typechecker.Typers

Typer

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

Linear Supertypes
Known Subclasses
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Typer
  2. TyperContextErrors
  3. PatternTyper
  4. Tag
  5. Adaptation
  6. TyperDiagnostics
  7. AnyRef
  8. Any
Implicitly
  1. by StringAdd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  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[Analyzer.Typer] performed by method StringAdd 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 ArrowAssoc 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: Mode, 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: Mode, 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: Mode, 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 canAdaptConstantTypeToLiteral: Boolean

    Overridden to false in scaladoc and/or interactive.

  21. def canTranslateEmptyListToNil: Boolean

  22. def checkClassType(tpt: Global.Tree): Boolean

    Check that tpt refers to a non-refinement class type

  23. object checkDead

    Definition Classes
    TyperDiagnostics
  24. def checkExistentialsFeature(pos: Global.Position, tpe: Global.Type, prefix: String): AnyVal

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

  26. def checkFinitary(classinfo: Global.ClassInfoType): Unit

  27. 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
  28. object checkNoEscaping extends Global.TypeMap

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

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

  30. def checkNonCyclic(sym: Global.Symbol): Unit

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

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

    Check that type tp is not a subtype of itself.

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

  34. def checkStablePrefixClassType(tpt: Global.Tree): Boolean

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

  35. object checkUnused

    Definition Classes
    TyperDiagnostics
  36. def checkValidAdaptation(t: Global.Tree, args: List[Global.Tree]): Boolean

    Definition Classes
    Adaptation
  37. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  38. def computeMacroDefType(ddef: Global.DefDef, pt: Global.Type): Global.Type

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

    Enter all aliases of local parameter accessors.

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

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

  42. var context: Analyzer.Context

  43. def context1: Analyzer.Context

  44. 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
  45. def doTypedApply(tree: Global.Tree, fun0: Global.Tree, args: List[Global.Tree], mode: Mode, pt: Global.Type): Global.Tree

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

    Definition Classes
    PatternTyper
  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 Ensuring 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 Ensuring 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 Ensuring 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 Ensuring 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): Global.Tree

    Definition Classes
    PatternTyper
  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[Analyzer.Typer] performed by method StringFormat 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. val infer: Analyzer.Inferencer

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

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

  66. def instantiate(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

  67. def instantiateExpectingUnit(tree: Global.Tree, mode: Mode): 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.

  68. def instantiatePossiblyExpectingUnit(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

  69. def isCapturedExistential(sym: Global.Symbol): Boolean

  70. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  71. def isNamedApplyBlock(tree: Global.Tree): Boolean

    Is tree a block created by a named application?

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

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

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

  75. def macroImplementationNotFoundMessage(name: Global.Name): String

    This file will be the death of me.

    This file will be the death of me.

    Attributes
    protected
    Definition Classes
    TyperContextErrors
  76. def member(qual: Global.Tree, name: Global.Name): Global.Symbol

    The member with given name of given qualifier tree

  77. def missingSelectErrorTree(tree: Global.Tree, qual: Global.Tree, name: Global.Name): Global.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 packedTypes(trees: List[Global.Tree]): List[Global.Type]

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

    Definition Classes
    TyperDiagnostics
  88. 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

  89. def reallyExists(sym: Global.Symbol): Boolean

    Is symbol defined and not stale?

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

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

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

    Report a type error.

    Report a type error.

    pos

    The position where to report the error

    ex

    The exception that caused the error

    Definition Classes
    TyperDiagnostics
  93. 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, IntTpe) 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
  94. 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, IntTpe, 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
  95. 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.

  96. val runDefinitions: reflect.internal.Definitions.definitions.RunDefinitions

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

  98. def stabilizeFun(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

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

    Definition Classes
    AnyRef
  100. def synthesizePartialFunction(paramName: Global.TermName, paramPos: Global.Position, tree: Global.Tree, mode: Mode, pt: 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

  101. def synthesizeSAMFunction(sam: Global.Symbol, fun: Global.Function, resPt: Global.Type, samClassTp: Global.Type, mode: Mode): Global.Tree

    Synthesize and type check the implementation of a type with a Single Abstract Method

    Synthesize and type check the implementation of a type with a Single Abstract Method

    { (p1: T1, ..., pN: TN) => body } : S

    expands to (where S is the expected type that defines a single abstract method named apply)

    { def apply$body(p1: T1, ..., pN: TN): T = body new S { def apply(p1: T1, ..., pN: TN): T = apply$body(p1,..., pN) } }

    If 'T' is not fully defined, it is inferred by type checking apply$body without a result type before type checking the block. The method's inferred result type is used instead of T. [See test/files/pos/sammy_poly.scala]

    The apply method is identified by the argument sam; S corresponds to the argument samClassTp, and resPt is derived from samClassTp -- it may be fully defined, or not...

    The function's body is put in a method outside of the class definition to enforce scoping. S's members should not be in scope in body.

    The restriction on implicit arguments (neither S's constructor, nor sam may take an implicit argument list), is largely to keep the implementation of type inference (the computation of samClassTpFullyDefined) simple.

    NOTE: it would be nicer to not have to type check apply$body separately when T is not fully defined. However T must be fully defined before we type the instantiation, as it'll end up as a parent type, which must be fully defined. Would be nice to have some kind of mechanism to insert type vars in a block of code, and have the instantiation of the first occurrence propagate to the rest of the block.

  102. def toString(): String

    Definition Classes
    AnyRef → Any
  103. def transformedOr(tree: Global.Tree, op: ⇒ Global.Tree): Global.Tree

  104. def transformedOrTyped(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

  105. def typed(tree: Global.Tree, mode: Mode): Global.Tree

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

    Types expression tree with given prototype pt.

  107. def typed(tree: Global.Tree): Global.Tree

    Types expression or definition tree.

  108. def typed(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

  109. def typed1(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

  110. def typedAnnotation(ann: Global.Tree, mode: Mode = EXPRmode, selfsym: Global.Symbol = NoSymbol): Global.AnnotationInfo

    Convert an annotation constructor call into an AnnotationInfo.

  111. def typedArg(arg: Global.Tree, mode: Mode, newmode: Mode, pt: Global.Type): Global.Tree

  112. def typedArgs(args: List[Global.Tree], mode: Mode): collection.immutable.List[Global.Tree]

  113. def typedArgsForFormals(args: List[Global.Tree], formals: List[Global.Type], mode: Mode): List[Global.Tree]

    Definition Classes
    PatternTyper
  114. def typedBlock(block0: Global.Block, mode: Mode, pt: Global.Type): Global.Block

  115. def typedByValueExpr(tree: Global.Tree, pt: Global.Type = WildcardType): Global.Tree

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

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

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

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

  120. def typedConstructorPattern(fun0: Global.Tree, pt: Global.Type): Global.Tree

    Definition Classes
    PatternTyper
  121. def typedDefDef(ddef: Global.DefDef): Global.DefDef

  122. def typedDocDef(docDef: Global.DocDef, mode: Mode, pt: Global.Type): Global.Tree

  123. def typedExistentialTypeTree(tree: Global.ExistentialTypeTree, mode: Mode): Global.Tree

    Attributes
    protected
  124. def typedHigherKindedType(tree: Global.Tree, mode: Mode): Global.Tree

  125. def typedHigherKindedType(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

    Types a higher-kinded type tree -- pt denotes the expected kind and must be one of Kind.WildCard and Kind.FromParams

  126. def typedImport(imp: Global.Import): Global.Import

  127. def typedInPattern(tree: Global.Typed, mode: Mode, pt: Global.Type): Global.Tree

    Attributes
    protected
    Definition Classes
    PatternTyper
  128. def typedLabelDef(ldef: Global.LabelDef): Global.LabelDef

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

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

  131. def typedModuleDef(mdef: Global.ModuleDef): Global.Tree

  132. def typedOperator(tree: Global.Tree): Global.Tree

    Types function part of an application

  133. def typedParentTypes(templ: Global.Template): List[Global.Tree]

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

    Types a pattern with prototype pt

  135. def typedPos(pos: Global.Position)(tree: Global.Tree): Global.Tree

  136. def typedPos(pos: Global.Position, mode: Mode, pt: Global.Type)(tree: Global.Tree): Global.Tree

  137. def typedQualifier(tree: Global.Tree): Global.Tree

  138. def typedQualifier(tree: Global.Tree, mode: Mode): 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.

  139. def typedQualifier(tree: Global.Tree, mode: Mode, 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.

  140. def typedRefinement(templ: Global.Template): Unit

  141. def typedStarInPattern(tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

    Attributes
    protected
    Definition Classes
    PatternTyper
  142. def typedStats(stats: List[Global.Tree], exprOwner: Global.Symbol): List[Global.Tree]

  143. def typedTemplate(templ0: Global.Template, parents1: List[Global.Tree]): Global.Template

    Check that inner classes do not inherit from Annotation

  144. def typedType(tree: Global.Tree): Global.Tree

    Types a (fully parameterized) type tree

  145. def typedType(tree: Global.Tree, mode: Mode): Global.Tree

    Types a (fully parameterized) type tree

  146. def typedTypeApply(tree: Global.Tree, mode: Mode, fun: Global.Tree, args: List[Global.Tree]): Global.Tree

    Attributes
    protected
  147. def typedTypeConstructor(tree: Global.Tree): Global.Tree

  148. def typedTypeConstructor(tree: Global.Tree, mode: Mode): Global.Tree

    Types a type constructor tree used in a new or supertype

  149. def typedTypeDef(tdef: Global.TypeDef): Global.TypeDef

  150. def typedValDef(vdef: Global.ValDef): Global.ValDef

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

    Annotations
    @inline()
  152. final def typerWithLocalContext[T](c: Analyzer.Context)(f: (Analyzer.Typer) ⇒ T): T

    Annotations
    @inline()
  153. 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.
  154. def viewExists(from: Global.Type, to: Global.Type): Boolean

  155. def virtualizedMatch(match_: Global.Match, mode: Mode, pt: Global.Type): Global.Tree

  156. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  157. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  158. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  159. final def withCondConstrTyper[T](inConstr: Boolean)(f: (Analyzer.Typer) ⇒ T): T

    Annotations
    @inline()
  160. final def withSavedContext[T](c: Analyzer.Context)(f: ⇒ T): T

    Annotations
    @inline()
  161. def wrapClassTagUnapply(uncheckedPattern: Global.Tree, classTagExtractor: Global.Tree, pt: Global.Type): Global.Tree

    Definition Classes
    PatternTyper
  162. 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 ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Inherited from Analyzer.PatternTyper

Inherited from Analyzer.Tag

Inherited from Analyzer.Adaptation

Inherited from Analyzer.TyperDiagnostics

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion StringAdd from Analyzer.Typer to StringAdd[Analyzer.Typer]

Inherited by implicit conversion StringFormat from Analyzer.Typer to StringFormat[Analyzer.Typer]

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

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

Ungrouped