TypeOps

The TypeMap handling the asSeenFrom

An approximating map that drops NamedTypes matching toAvoid and wildcard types.

An argument bounds violation is a triple consisting of

• the argument tree
• a string "upper" or "lower" indicating which bound is violated
• the violated bound

The type tp as seen from prefix pre and owner cls. See the spec for what this means.

An upper approximation of the given type tp that does not refer to any symbol in symsToAvoid and does not contain any WildcardType. We need to approximate with ranges:

term references to symbols in symsToAvoid, term references that have a widened type of which some part refers to a symbol in symsToAvoid, type references to symbols in symsToAvoid,

Type variables that would be interpolated to a type that needs to be widened are replaced by the widened interpolation instance.

TODO: Could we replace some or all usages of this method by LevelAvoidMap instead? It would be good to investigate this in details but when I tried it, avoidance for inlined trees broke because TreeMap does not update ctx.nestingLevel when entering a block so I'm leaving this as Future Work™.

The list of violations where arguments are not within bounds.

computes a prefix for child, derived from its common prefix with pre

• pre is assumed to be the prefix of parent at a given callsite.
• child is assumed to be the sealed child of parent, and reachable according to whyNotGenericSum.

An abstraction of a class info, consisting of

• the intersection of its parents,
• refined by all non-private fields, methods, and type members,
• abstracted over all type parameters (into a type lambda)
• where all references to this of the class are closed over in a RecType.

If tpe is of the form p.x where p refers to a package but x is not owned by a package, expand it to

p.package.x

Approximate union type by intersection of its dominators. That is, replace a union type Tn | ... | Tn by the smallest intersection type of base-class instances of T1,...,Tn. Example: Given

trait C[+T]
trait D
class A extends C[A] with D
class B extends C[B] with D with E

we approximate A | B by C[A | B] with D.

Before we do that, we try to find a common non-class supertype of T1 | ... | Tn in a "best effort", ad-hoc way by selectively widening types in T1, ..., Tn and stopping if the resulting union simplifies to a type that is not a disjunction.

Refine child based on parent

In child class definition, we have:

class Child[Ts] extends path.Parent[Us] with Es
object Child extends path.Parent[Us] with Es
val child = new path.Parent[Us] with Es           // enum values

Given a parent type parent and a child symbol child, we infer the prefix and type parameters for the child:

prefix.child[Vs] <:< parent

where Vs are fresh type variables and prefix is the symbol prefix with all non-module and non-package ThisType replaced by fresh type variables.

If the subtyping is true, the instantiated type p.child[Vs] is returned. Otherwise, NoType is returned.

Implementation of Types#simplified

Apply Type.stripTypeVar recursively.