Constructors

Checker ( phasesToCheck: Seq [ Phase ] )

Members

[+] val everDefinedSyms : HashMap [ Symbol, Tree ]

[+] val nowDefinedSyms : HashSet [ Symbol ]

[+] private val phasesToCheck : Seq [ Phase ]

[+] override def adapt ( tree: Tree , pt: Type , original: Tree ) ( implicit ctx: Context ) : Tree

[+] def adapt$default$3 : Thicket

[+] def assertDefined ( tree: Tree ) ( implicit ctx: Context ) : Unit

[+] def assertIdentNotJavaClass ( tree: Tree ) ( implicit ctx: Context ) : Unit

assert Java classes are not used as objects

[+] override def checkDerivedValueClass ( clazz: Symbol , stats: List [ Tree ] ) ( implicit ctx: Context ) : Unit

Verify classes extending AnyVal meet the requirements

[+] def checkIdentNotJavaClass ( tree: Tree ) ( implicit ctx: Context ) : Unit

check Java classes are not used as objects

[+] def checkNoOrphans ( tp: Type ) ( implicit ctx: Context ) : Type

Check that PolyParams and MethodParams refer to an enclosing type

[+] def checkNotRepeated ( tree: Tree ) ( implicit ctx: Context ) : tree.type

[+] private def checkOwner ( tree: Tree ) ( implicit ctx: Context ) : Unit

[+] override def ensureNoLocalRefs ( tree: Tree , pt: Type , localSyms: => List [ Symbol ] , forcedDefined: Boolean ) ( implicit ctx: Context ) : Tree

Check that expression's type can be expressed without references to locally defined symbols. The following two remedies are tried before giving up: 1. I...

Check that expression's type can be expressed without references to locally defined symbols. The following two remedies are tried before giving up: 1. If the expected type of the expression is fully defined, pick it as the type of the result expressed by adding a type ascription. 2. If (1) fails, force all type variables so that the block's type is fully defined and try again.

[+] def ensureNoLocalRefs$default$4 : Boolean

Check that expression's type can be expressed without references to locally defined symbols. The following two remedies are tried before giving up: 1. I...

[+] def isMethodType ( pt: Type ) ( implicit ctx: Context ) : Boolean

Check that all methods have MethodicType

[+] override def typed ( tree: Tree , pt: Type ) ( implicit ctx: Context ) : Tree

[+] def typed$default$2 : WildcardType$

[+] override def typedBlock ( tree: Block , pt: Type ) ( implicit ctx: Context ) : Tree [ T ]

[+] override def typedCase ( tree: CaseDef , pt: Type , selType: Type , gadtSyms: Set [ Symbol ] ) ( implicit ctx: Context ) : CaseDef

Type a case. Overridden in ReTyper, that's why it's separate from typedCases.

[+] override def typedClassDef ( cdef: TypeDef , cls: ClassSymbol ) ( implicit ctx: Context ) : TypeDef [ Type ]

[+] override def typedDefDef ( ddef: DefDef , sym: Symbol ) ( implicit ctx: Context ) : DefDef [ Type ]

[+] override def typedIdent ( tree: Ident , pt: Type ) ( implicit ctx: Context ) : Tree

Attribute an identifier consisting of a simple name or wildcard

[+] override def typedInlined ( tree: Inlined , pt: Type ) ( implicit ctx: Context ) : Inlined

[+] override def typedSelect ( tree: Select , pt: Type ) ( implicit ctx: Context ) : Tree

Makes sure the symbol in the tree can be approximately reconstructed by calling member on the qualifier type. Approximately means: The two symbols might...

Makes sure the symbol in the tree can be approximately reconstructed by calling member on the qualifier type. Approximately means: The two symbols might be different but one still overrides the other.

[+] override def typedStats ( trees: List [ Tree ] , exprOwner: Symbol ) ( implicit ctx: Context ) : List [ Tree ]

Check that all defined symbols have legal owners. An owner is legal if it is either the same as the context's owner or there's an owner chain of valdefs...

Check that all defined symbols have legal owners. An owner is legal if it is either the same as the context's owner or there's an owner chain of valdefs starting at the context's owner and reaching up to the symbol's owner. The reason for this relaxed matching is that we should be able to pull out an expression as an initializer of a helper value without having to do a change owner traversal of the expression.

[+] override def typedThis ( tree: This ) ( implicit ctx: Context ) : Tree

[+] override def typedUnadapted ( tree: Tree , pt: Type ) ( implicit ctx: Context ) : Tree

[+] def withDefinedSym ( tree: Tree ) ( op: => T ) ( implicit ctx: Context ) : T

[+] def withDefinedSyms ( trees: List [ Tree ] ) ( op: => T ) ( implicit ctx: Context ) : T

[+] def withDefinedSymss ( vparamss: List [ List [ ValDef ] ] ) ( op: => T ) ( implicit ctx: Context ) : T