CaptureChecker

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

Assert subcapturing cs1 <: cs2

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.

Massage actual and expected types using the methods below before checking conformance

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

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 {*} on the self type. If a class without explicit self type is not effectivelyFinal 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

For all nested environments up to limit perform op

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 call is to a constructor:
  • remember types of arguments corresponding to tracked parameters in refinements.
  • add capture set of instantiated class to capture set of result type.

Should type of tree be kept in an attachment so that it can be retrieved with knownType? By default true only is keepAllTypes hold, but can be overridden.

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

Make sure (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

Perform the following kinds of checks

• Check all explicitly written capturing types for well-formedness using checkWellFormedPost.
• Check that externally visible vals or defs have empty capture sets. If not, suggest an explicit type. This is so that separate compilation (where external symbols have empty capture sets) gives the same results as joint compilation.
• Check that arguments of TypeApplys and AppliedTypes conform to their bounds.
• Heal ill-formed capture sets of type parameters. See healTypeParam.

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

A specialized implementation of the apply rule.

E |- f: Cf (Ra -> Cr Rr) E |- a: Ca Ra

E |- f a: C Rr

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

Additionally to normal processing, update types of closures if the expected type is a function with only pure parameters. In that case, make the anonymous function also have the same parameters as the prototype. TODO: Develop a clearer rationale for this. TODO: Can we generalize this to arbitrary parameters? Currently some tests fail if we do this. (e.g. neg.../stackAlloc.scala, others)

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.

If tree is a reference or an application where the result type refers to an enclosing class or method parameter of the reference, check that the result type does not capture the universal capability. This is justified since the result type would have to be implicitly unboxed. TODO: Can we find a cleaner way to achieve this? Logically, this should be part of simulated boxing and unboxing.

A specialized implementation of the selection rule.

E |- f: Cf f { m: Cr R }

E |- f.m: C R

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

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.

Check that widened types of tpe and pt are compatible.

When we select the apply of a function with type such as (=> A) => B, we need to convert the parameter type => A to () ?=> A. See doc comment of mapExprType.

Recheck tree without adapting it, returning its new type.

Typing and previous transforms sometiems 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.