Var

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

Add a specific element, assuming it is not already accounted for, and omitting any mapping or filtering, without possibility to backtrack to the underlying capture set.

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

The elements of this capture set. For capture variables, the elements known so far.

Invoke handler on the elements to ensure wellformedness of the capture set. The handler might add additional elements to the capture set.

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 set provisionally solved, so that another cc run might unfreeze it?

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

Adds variables to the ShownVars context property if that exists, which establishes a record of all variables printed in an error message. Returns variable ids under -Ycc-debug, and owner/nesting level info under -Yprint-level.

An optional owner, or NoSymbol if none exists. Used for diagnstics

Reset dependent sets to what was recorded in state

Reset elements to what was recorded in state

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.

Returns a string representation of the object.

The default representation is platform dependent.

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 {cap} is a sound fallback.

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

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.

Convert to Const. @pre: isConst

Cast to variable. @pre: !isConst

Does this capture set contain a root reference cap or cap.rd as element?

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 definitely non-empty?

Does this capture set contain the root reference cap 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 we handle this as follows:

• If the map is a BiTypeMap, the same transformation is applied to all future additions of new elements. We try to fuse with previous maps to avoid long paths of BiTypeMapped sets.
• If the map is some other map that maps the current set of elements to itself, return the current var. We implicitly assume that the map will also map any elements added in the future to themselves. This assumption can be tested to hold by setting the ccConfig.checkSkippedMaps setting to true.
• If the map is some other map that does not map all elements to themselves, freeze the current set (i.e. make it porvisionally solved) and return the mapped elements as a constant set.

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 cap.

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, and the same is not true in reverse when we compare elements of cs2 vs cs1.

Apply function f to the elements. Typically used for printing. Overridden in HiddenSet so that we don't run into infinite recursions

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.

The subcapturing test, using a given VarState

The subcapturing test, taking an explicit VarState.

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

Convert to Const with current elements unconditionally

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

The text representation of this showable element. This normally dispatches to a pattern matching method in Printers.

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

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

A unique identification number for diagnostics

An optional level limit, or undefinedLevel if none exists. All elements of the set must be at levels equal or smaller than the level of the set, if it is defined.

A handler to be invoked when new elems are added to this set

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