BiMapped

Add new elements to this capture set if allowed.

For a BiTypeMap, supertypes of the mapped type also constrain the source via the inverse type mapping and vice versa. That is, if B = f(A) and B <: C, then A <: f^-1(C), so C should flow into the upper approximation of A. Conversely if A <: C2, then we also know that B <: f(C2). These situations are modeled by the two branches of the conditional below.

Returns a string representation of the object.

The default representation is platform dependent.

The largest capture set (via <:<) that is a subset of both this and that

The smallest superset (via <:<) of this capture set that also contains ref.

The smallest capture set (via <:<) that is a superset of both this and that

The largest subset (via <:<) of this capture set that does not account for ref

The largest subset (via <:<) of this capture set that does not account for any of the elements in the constant capture set that

Two capture sets are considered =:= equal if they mutually subcapture each other in a frozen state.

{x} <:< this where <:< is subcapturing, but treating all variables as frozen.

If this is a variable, add cs as a dependent set

Convert to Const. @pre: isConst

Cast to variable. @pre: !isConst

Invoke handler if this set has (or later aquires) the root capability *

A fallback text representation, if the pattern matching in Printers does not have a case for this showable element

The largest subset (via <:<) of this capture set that only contains elements for which p is true.

Is this capture set always empty? For unsolved capture veriables, returns always false.

Is this capture set constant (i.e. not an unsolved capture variable)? Solved capture variables count as constant.

Is this capture set definitely non-empty?

Does this capture set contain the root reference * as element?

Capture set obtained by applying tm to all elements of the current capture set and joining the results. If the current capture set is a variable, the same transformation is applied to all future additions of new elements.

Note: We have a problem how we handle the situation where we have a mapped set

cs2 = tm(cs1)

and then the propagation solver adds a new element x to cs2. What do we know in this case about cs1? We can answer this question in a sound way only if tm is a bijection on capture references or it is idempotent on capture references. (see definition in IdempotentCapRefMap). If tm is a bijection we know that tm^-1(x) must be in cs1. If tm is idempotent one possible solution is that x is in cs1, which is what we assume in this case. That strategy is sound but not complete.

If tm is some other map, we don't know how to handle this case. For now, we simply refuse to handle other maps. If they do need to be handled, OtherMapped provides some approximation to a solution, but it is neither sound nor complete.

Mark set as solved and propagate this info to all dependent sets

A more optimistic version of accountsFor, which does not take variable supersets of the x reference into account. A set might account for x if it accounts for x in a state where we assume all supersets of x have just the elements known at this point. On the other hand if x's capture set has no known elements, a set cs might account for x only if it subsumes x or it contains the root capability *.

A more optimistic version of subCaptures used to choose one of two typing rules for selections and applications. cs1 mightSubcapture cs2 if cs2 might account for every element currently known to be in cs1.

Assuming set this set dependds on was just solved to be constant, propagate this info to this set. This might result in the set being solved to be constant itself.

Reset dependent sets to what was recorded in state

Reset elements to what was recorded in state

The string representation of this showable element.

The string representation with each line after the first one indented by the given given margin (in spaces).

The summarized string representation of this showable element. Recursion depth is limited to some smallish value. Default is Config.summarizeDepth.

Widen the variable's elements to its upper approximation and mark it as constant from now on. This is used for contra-variant type variables in the results of defs and vals.

The subcapturing test.

A mapping resulting from substituting parameters of a BindingType to a list of types

A regular @retains or @retainsByName annotation with the elements of this set as arguments.

Adds variables to the ShownVars context property if that exists, which establishes a record of all variables printed in an error message. Prints variables wih ids under -Ycc-debug.

Roughly: the intersection of all constant known supersets of this set. The aim is to find an as-good-as-possible constant set that is a superset of this set. The universal set {*} is a sound fallback.

This capture set with a description that tells where it comes from

The variable from which this variable is derived

The sets currently known to be dependent sets (i.e. new additions to this set are propagated to these dependent sets.)

The provided description (using withDescription) for this capture set or else ""

The elements currently known to be in the set

A unique identification number for diagnostics

A handler to be invoked if the root reference * is added to this set