CaptureChecker

Adapt actual type to expected type. This involves:

• narrow toplevel captures of x's underlying type to {x} according to CC's VAR rule
• narrow nested captures of x's underlying type to {x*}
• do box adaptation

Adapt actual type to expected type by inserting boxing and unboxing conversions

Assert subcapturing cs1 <: cs2 (available for debugging, otherwise unused)

If sym is a class or method nested inside a term, a capture set variable representing the captured variables of the environment associated with sym.

Under the unsealed policy: Arrays are like vars, check that their element types do not contains cap (in fact it would work also to check on array creation like we do under sealed).

Massage actual and expected types before checking conformance. Massaging is done by the methods following this one:

• align dependent function types and add outer references in the expected type
• adapt boxing in the actual type If the resulting types are not compatible, try again with an actual type where local capture roots are instantiated to root variables.

Faced with a tree of form caps.contansImpl[CS, r.type], check that R is a tracked capability and assert that {r} <: CS.

Check subcapturing {elem} <: cs, report error on failure

If val or def definition with inferred (result) type is visible in other compilation units, check that the actual inferred type conforms to the expected type where all inferred capture sets are dropped. This ensures that if files compile separately, they will also compile in a joint compilation.

If res is not CompareResult.OK, report an error

Check overrides again, taking capture sets into account. TODO: Can we avoid doing overrides checks twice? We need to do them here since only at this phase CaptureTypes are relevant But maybe we can then elide the check during the RefChecks phase under captureChecking?

Check that self types of subclasses conform to self types of super classes. (See comment below how this is achieved). The check assumes that classes without an explicit self type have the universal capture set {cap} on the self type. If a class without explicit self type is not effectivelySealed it is checked that the inferred self type is universal, in order to assure that joint and separate compilation give the same result.

Check subcapturing cs1 <: cs2, report error on failure

Check a ValDef or DefDef as an action performed in a completer. Since these checks can appear out of order, we need to first create the correct environment for checking the definition.

Under the sealed policy, disallow the root capability in type arguments. Type arguments come either from a TypeApply node or from an AppliedType which represents a trait parent in a template. Also, if a corresponding formal type parameter is declared or implied @use, charge the deep capture set of the argument to the environent.

Include references captured by the called method in the current environment stack

Handle an application of method sym with type mt to arguments of types argTypes. This means

• Instantiate result type with actual arguments
• if sym is a constructor, refine its type with refineInstanceType If all argument types are mutually different trackable capture references, use a BiTypeMap, since that is more precise. Otherwise use a normal idempotent map, which might lose information in the case where the result type contains captureset variables that are further constrained afterwards.

Does the given environment belong to a method that is (a) nested in a term and (b) not the method of an anonympus function?

Include sym in the capture sets of all enclosing environments nested in the the environment in which sym is defined.

Make sure the (projected) cs is a subset of the capture sets of all enclosing environments. At each stage, only include references from cs that are outside the environment's owner

The next environment enclosing env that needs to be charged with free references.

Perform the following kinds of checks

• Check that arguments of TypeApplys and AppliedTypes conform to their bounds.
• Heal ill-formed capture sets of type parameters. See healTypeParam.

Perform the following kinds of checks:

• Check all explicitly written capturing types for well-formedness using checkWellFormedPost.
• Check that publicly visible inferred types correspond to the type they have without capture checking.

Hook for massaging a function before it is applied. Copies all @use annotations on method parameter symbols to the corresponding paramInfo types.

The main recheck method does some box adapation for all nodes:

• If expected type pt is boxed and the tree is a lambda or a reference, don't propagate free variables.
• If the expected type is not boxed but the result type is boxed, simulate an unboxing by adding all references in the boxed capture set of the result type to the current environment.

Recheck applications, with special handling of unsafeAssumePure. More work is done in recheckApplication, recheckArg and instantiate below.

Recheck classDef by enforcing the following class-specific capture set relations:

1. The capture set of a class includes the capture sets of its parents.
2. The capture set of the self type of a class includes the capture set of the class.
3. The capture set of the self type of a class includes the capture set of every class parameter, unless the parameter is marked @constructorOnly or @untrackedCaptures.
4. If the class extends a pure base class, the capture set of the self type must be empty. Also, check that trait parents represented as applied types don't have cap in their type arguments. Other generic parents are represented as TypeApplys, where the same check is already done in the TypeApply.

Recheck Closure node: add the captured vars of the anonymoys function to the result type. See also recheckClosureBlock which rechecks the block containing the anonymous function and the Closure node.

Recheck a lambda of the form { def $anonfun(...) = ...; closure($anonfun, ...)}

Recheck method definitions:

• check body in a nested environment that tracks uses, in a nested level, and in a nested context that knows abaout Contains parameters so that we can assume they are true.
• for externally visible definitions: check that their inferred type does not refine what was known before capture checking.
• Interpolate contravariant capture set variables in result type unless def is anonymous.

Under the old unsealed policy: check that cap is ot unboxed

A specialized implementation of the selection rule.

E |- f: T{ m: R^Cr }^{f}

E |- f.m: R^C

The implementation picks as C one of {f} or Cr, depending on the outcome of a mightSubcapture test. It picks {f} if it might subcapture Cr and picks Cr otherwise.

Under the sealed policy and with saferExceptions, disallow cap in the result type of a try

Recheck type applications:

• Map existential captures in result to cap
• include captures of called methods in environment
• don't allow cap to appear covariantly in type arguments
• special handling of contains[A, B] calls

If type is of the form T @requiresCapability(x), mark x as free in the current environment. This is used to require the correct CanThrow capability when encountering a throw.

Recheck val and var definitions:

• disallow cap in the type of mutable vars.
• for externally visible definitions: check that their inferred type does not refine what was known before capture checking.
• Interpolate contravariant capture set variables in result type.

The expected type for the qualifier of a selection. If the selection could be part of a capabaility path, we return a PathSelectionProto.

Elements of a SeqLiteral instantiate a Seq or Array parameter, so they should be boxed.

The normal rechecking if sym was already completed before

Check that widened types of tpe and pt are compatible.

If true, remember the new types of nodes in this compilation unit as an attachment in the unit's tpdTree node. By default, this is enabled when -Xprint:cc is set. Can be overridden.

Recheck tree without adapting it, returning its new type.

Reset all references in prevSelDenots to the denotations they had before this phase.

Typing and previous transforms sometimes leaves skolem types in prefixes of NamedTypes in expected that do not match the actual Type. -Ycheck does not complain (need to find out why), but a full recheck does. We compensate by de-skolemizing everywhere in expected except when variance is negative.