SpaceEngine

Is a a subspace of b? Equivalent to simplify(simplify(a) - simplify(b)) == Empty, but faster

Simplify space such that a space equal to Empty becomes Empty

Whether the extractor covers the given type

Decompose a type into subspaces -- assume the type can be decomposed

Remove a space if it's a subspace of remaining spaces

Note: dedup will return the same result if the sequence >= 10

Flatten space to get rid of Or for pretty print

Intersection of two spaces

Return a space containing the values of both types.

The types should be atomic (non-decomposable) and unrelated (neither should be a subtype of the other).

Is the unapply or unapplySeq irrefutable?

Is the unapply or unapplySeq irrefutable?

Is this an '{..} or '[..] irrefutable quoted patterns?

True if we can assume that the two unapply methods are the same. That is, given the same parameter, they return the same result.

We assume that unapply methods are pure, but the same method may be called with different prefixes, thus behaving differently.

Is tp1 a subtype of tp2?

The space of a not covered by b

Return the space that represents the pattern pat

Space of the pattern: unapplySeq(a, b, c: _*)

Whether the counterexample is satisfiable. The space is flattened and non-empty.

Display spaces

Show friendly type name with current scope in mind

E.g. C.this.B --> B if current owner is C C.this.x.T --> x.T if current owner is C X[T] --> X C --> C if current owner is C !!!

Return term parameter types of the extractor unapp. Parameter types of the case class type tp. Adapted from unapplyPlan in patternMatcher

Return the underlying type of non-module, non-constant, non-enum case singleton types. Also widen ExprType to its result type, and rewrap any annotation wrappers. For example, with val opt = None, widen opt.type to None.type.