Dotty Documentation


object Checking
extends Object with Serializable

[-] Constructors

[-] Members

[+] class CheckNonCyclicMap

A type map which checks that the only cycles in a type are F-bounds and that protects all F-bounded references by LazyRefs.

[+] def checkAppliedType ( tree: AppliedTypeTree , boundsCheck: Boolean ) ( implicit ctx: Context ) : Unit

Check applied type trees for well-formedness. This means - all arguments are within their corresponding bounds - if type is a higher-kinded application with wildcard arguments, check that it or one of its supertypes can be reduced to a normal application. Unreducible applications correspond to general existentials, and we cannot handle those.

[+] def checkBounds ( args: List [ Tree ] , boundss: List [ TypeBounds ] , instantiate: (Type, List [ Type ]) => Type ) ( implicit ctx: Context ) : Unit

A general checkBounds method that can be used for TypeApply nodes as well as for AppliedTypeTree nodes. Also checks that type arguments to *-type parameters are fully applied.

[+] def checkBounds ( args: List [ Tree ] , tl: TypeLambda ) ( implicit ctx: Context ) : Unit

Check that type arguments args conform to corresponding bounds in tl Note: This does not check the bounds of AppliedTypeTrees. These are handled by method checkBounds in FirstTransform

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

Verify classes extending AnyVal meet the requirements

[+] def checkInstantiable ( tp: Type , posd: Positioned ) ( implicit ctx: Context ) : Unit

Check that tp refers to a nonAbstract class and that the instance conforms to the self type of the created class.

[+] def checkNoPrivateLeaks ( sym: Symbol , pos: SourcePosition ) ( implicit ctx: Context ) : Type

Check the type signature of the symbol M defined by tree does not refer to a private type or value which is invisible at a point where M is still visible.

As an exception, we allow references to type aliases if the underlying type of the alias is not a leak, and if sym is not a type. The rationale for this is that the inferred type of a term symbol might contain leaky aliases which should be removed (see leak-inferred.scala for an example), but a type symbol definition will not contain leaky aliases unless the user wrote them, so we can ask the user to change his definition. The more practical reason for not transforming types is that checkNoPrivateLeaks can force a lot of denotations, and this restriction means that we never need to run TypeAssigner#avoidPrivateLeaks on type symbols when unpickling, which avoids some issues related to forcing order.

See i997.scala for negative tests, and i1130.scala for a case where it matters that we transform leaky aliases away.

[+] def checkNoWildcard ( tree: Tree ) ( implicit ctx: Context ) : Tree
[+] def checkNonCyclic ( sym: Symbol , info: Type , reportErrors: Boolean ) ( implicit ctx: Context ) : Type

Check that info of symbol sym is not cyclic.

[+] def checkNonCyclicInherited ( joint: Type , parents: List [ Type ] , decls: Scope , posd: Positioned ) ( implicit ctx: Context ) : Unit

Check type members inherited from different parents of joint type for cycles, unless a type with the same name aleadry appears in decls.

[+] def checkRealizable ( tp: Type , posd: Positioned , what: String ) ( implicit ctx: Context ) : Unit

Check that type tp is realizable.

[+] def checkRealizable$default$3 : String

Check that type tp is realizable.

[+] def checkRefinementNonCyclic ( refinement: Tree , refineCls: ClassSymbol , seen: Set [ Symbol ] ) ( implicit ctx: Context ) : Unit

Check that refinement satisfies the following two conditions 1. No part of it refers to a symbol that's defined in the same refinement at a textually later point. 2. All references to the refinement itself via this are followed by selections. Note: It's not yet clear what exactly we want to allow and what we want to rule out. This depends also on firming up the DOT calculus. For the moment we only issue deprecated warnings, not errors.

[+] def checkWellFormed ( sym: Symbol ) ( implicit ctx: Context ) : Unit

Check that symbol's definition is well-formed.

[+] def preCheckKind ( arg: Tree , paramBounds: Type ) ( implicit ctx: Context ) : Tree

Check that kind of arg has the same outline as the kind of paramBounds. E.g. if paramBounds has kind * -> *, arg must have that kind as well, and analogously for all other kinds. This kind checking does not take into account variances or bounds. The more detailed kind checking is done as part of checkBounds in PostTyper. The purpose of preCheckKind is to do a rough test earlier in Typer, in order to prevent scenarios that lead to self application of types. Self application needs to be avoided since it can lead to stack overflows. Test cases are neg/i2771.scala and neg/i2771b.scala. A NoType paramBounds is used as a sign that checking should be suppressed.

[+] def preCheckKinds ( args: List [ Tree ] , paramBoundss: List [ Type ] ) ( implicit ctx: Context ) : List [ Tree ]