dotty.tools.dotc.core

Indicates the singleton types that a type must or may consist of.

Realizability status

Compute realizability status.

A type T is realizable iff it is inhabited by non-null values. This ensures that its type members have good bounds (in the sense from DOT papers). A type projection T#L is legal if T is realizable, and can be understood as Scala 2's v.L forSome { val v: T }.

In general, a realizable type can have multiple inhabitants, hence it need not be stable (in the sense of Type.isStable).

Constraint over undetermined type parameters. Constraints are built over values of the following types:

• TypeLambda A constraint constrains the type parameters of a set of TypeLambdas
• TypeParamRef The parameters of the constrained type lambdas
• TypeVar Every constrained parameter might be associated with a TypeVar that has the TypeParamRef as origin.

Methods for adding constraints and solving them.

What goes into a Constraint as opposed to a ConstrainHandler?

Constraint code is purely functional: Operations get constraints and produce new ones. Constraint code does not have access to a type-comparer. Anything regarding lubs and glbs has to be done elsewhere.

By comparison: Constraint handlers are parts of type comparers and can use their functionality. Constraint handlers update the current constraint as a side effect.

Extension methods for contexts where we want to keep the ctx. syntax

This TypeError signals that completing denot encountered a cycle: it asked for denot.info (or similar), so it requires knowing denot already.

This object provides useful implicit decorators for types defined elsewhere

A class defining symbols and types of standard definitions

Denotations represent the meaning of symbols and named types. The following diagram shows how the principal types of denotations and their denoting entities relate to each other. Lines ending in a down-arrow v are member methods. The two methods shown in the diagram are "symbol" and "deref". Both methods are parameterized by the current context, and are effectively indexed by current period.

Lines ending in a horizontal line mean subtyping (right is a subtype of left).

NamedType | Symbol---------ClassSymbol | | | | denot | denot | denot v v v Denotation-+-----SingleDenotation-+------SymDenotation-+----ClassDenotation | | +-----MultiDenotation | | +--UniqueRefDenotation +--JointRefDenotation

Here's a short summary of the classes in this diagram.

NamedType A type consisting of a prefix type and a name, with fields prefix: Type name: Name It has two subtypes: TermRef and TypeRef Symbol A label for a definition or declaration in one compiler run ClassSymbol A symbol representing a class Denotation The meaning of a named type or symbol during a period MultiDenotation A denotation representing several overloaded members SingleDenotation A denotation representing a non-overloaded member or definition, with main fields symbol: Symbol info: Type UniqueRefDenotation A denotation referring to a single definition with some member type JointRefDenotation A denotation referring to a member that could resolve to several definitions SymDenotation A denotation representing a single definition with its original type, with main fields name: Name owner: Symbol flags: Flags privateWithin: Symbol annotations: List[Annotation] ClassDenotation A denotation representing a single class definition.

A type comparer that can record traces of subtype operations

Represents GADT constraints currently in scope

This module defines methods to interpret types of Java symbols, which are implicitly nullable in Java, as Scala types, which are explicitly nullable.

The transformation is (conceptually) a function n that adheres to the following rules: (1) n(T) = T | Null if T is a reference type (2) n(T) = T if T is a value type (3) n(C[T]) = C[T] | Null if C is Java-defined (4) n(C[T]) = C[n(T)] | Null if C is Scala-defined (5) n(A|B) = n(A) | n(B) | Null (6) n(A&B) = n(A) & n(B) (7) n((A1, ..., Am)R) = (n(A1), ..., n(Am))n(R) for a method with arguments (A1, ..., Am) and return type R (8) n(T) = T otherwise

Treatment of generics (rules 3 and 4):

• if C is Java-defined, then n(C[T]) = C[T] | Null. That is, we don't recurse on the type argument, and only add Null on the outside. This is because C itself will be nullified, and in particular so will be usages of C's type argument within C's body. e.g. calling get on a java.util.List[String] already returns String|Null and not String, so we don't need to write java.util.List[String | Null].
• if C is Scala-defined, however, then we want n(C[T]) = C[n(T)] | Null. This is because C won't be nullified, so we need to indicate that its type argument is nullable.

Notice that since the transformation is only applied to types attached to Java symbols, it doesn't need to handle the full spectrum of Scala types. Additionally, some kinds of symbols like constructors and enum instances get special treatment.

A utility module to produce match type reduction traces in error messages.

A collection of mode bits that are part of a context

Defines possible kinds of NameInfo of a derived name

The possible tags of a NameKind

Operations that are shared between Namer and TreeUnpickler

A NoCompleter which is also a SymbolLoader.

Defines operations on nullable types and tree.

Constraint over undetermined type parameters that keeps separate maps to reflect parameter orderings.

A common super trait of Symbol and LambdaParam. Used to capture the attributes of type parameters which can be implemented as either.

The signature of a denotation.

Same-named denotations with different signatures are considered to be overloads, see SingleDenotation#matches for more details.

A method signature (a value of type Signature, excluding NotAMethod and OverloadedSignature) is composed of a list of parameter signatures, plus a type signature for the final result type.

A parameter signature (a value of type ParamSig) is either an integer, representing the number of type parameters in a type parameter section, or the type signature of a term parameter.

A type signature is the fully qualified name of the type symbol of the type's erasure.

For instance a definition

def f[T, S](x: Int)(y: List[T]): S

would have signature

Signature(
  List(2, "scala.Int".toTypeName, "scala.collection.immutable.List".toTypeName),
  "java.lang.Object".toTypeName)

Note that paramsSig has one entry for a whole type parameter section but one entry for each term parameter (currently, methods in Dotty can only have one type parameter section but this encoding leaves the door open for supporting multiple sections).

The signatures of non-method types are always NotAMethod.

There are three kinds of "missing" parts of signatures:

• tpnme.EMPTY Result type marker for NotAMethod and OverloadedSignature
• tpnme.WILDCARD Arises from a Wildcard or error type
• tpnme.Uninstantiated Arises from an uninstantiated type variable

The language in which the definition being erased was written.

Substitution operations on types. See the corresponding subst and substThis methods on class Type for an explanation.

A lazy type that completes itself by calling parameter doComplete. Any linked modules/classes or module classes are also initialized.

A decorator that provides methods for modeling type application

Provides methods to compare types.

Erased types are:

ErasedValueType TypeRef(prefix is ignored, denot is ClassDenotation) TermRef(prefix is ignored, denot is SymDenotation) JavaArrayType AnnotatedType MethodType ThisType SuperType ClassInfo (NoPrefix, ...) NoType NoPrefix WildcardType ErrorType

only for isInstanceOf, asInstanceOf: PolyType, TypeParamRef, TypeBounds

When calling Constraint#addLess(p1, p2, ...), the caller might end up unifying one parameter with the other, this enum lets addLess know which direction the unification will take.

Defines operation unique for hash-consing types. Also defines specialized hash sets for hash consing uniques of a specific type. All sets offer a enterIfNew method which checks whether a type with the given parts exists already and creates a new one if not.

Post-process exceptions that might result from StackOverflow to add tracing information while unwalking the stack.