Definitions

Extractor for context function types representing by-name parameters, of the form () ?=> T. Under purefunctions, this becomes () ?-> T or {r1, ..., rN} () ?-> T.

An extractor for context function types As ?=> B, possibly with dependent refinements. Optionally returns a triple consisting of the argument types As, the result type B and a whether the type is an erased context function.

An extractor for multi-dimensional arrays. Note that this will also extract the high bound if an element type is a wildcard upper-bounded by an array. E.g.

Array[? <: Array[? <: Number]]

would match

MultiArrayOf(<? <: Number>, 2)

The enumeration type, goven a value of the enumeration

If it is BoxedUnit, remove java.io.Serializable from parents.

If cls is Tuple1..Tuple22, add the corresponding *: type as last parent to parents

Return underlying context function type (i.e. instance of an ContextFunctionN class) or NoType if none exists. The following types are considered as underlying types:

• the alias of an alias type
• the instance or origin of a TypeVar (i.e. the result of a stripTypeVar)
• the upper bound of a TypeParamRef in the current constraint

The type of the boxed class corresponding to primitive value type tp.

Returns the erased type of the function class cls

• FunctionN for N > 22 becomes FunctionXXL
• FunctionN for 22 > N >= 0 remains as FunctionN
• ContextFunctionN for N > 22 becomes FunctionXXL
• ContextFunctionN for N <= 22 becomes FunctionN
• anything else becomes a NoType

When typing a primitive value class or AnyVal, we ignore the getClass member: it's supposed to be an override of the getClass defined on Any, but in dotty Any#getClass is polymorphic so it ends up being an overload. This is especially problematic because it means that when writing:

1.asInstanceOf[Int & AnyRef].getClass

the getClass that returns Class[Int] defined in Int can be selected, but this call is specified to return classOf[Integer], see tests/run/t5568.scala.

FIXME: remove all the getClass methods defined in the standard library so we don't have to hot-patch it like this.

A whitelist of Scala-2 classes that are known to be pure

Is an context function class.

• ContextFunctionN for N >= 0

Is tp an context function type?

Is any function class where

• FunctionXXL
• FunctionN for N >= 0
• ContextFunctionN for N >= 0

Returns whether tp is an instance or a refined instance of:

• scala.FunctionN
• scala.ContextFunctionN

Is a function class, or an impure function type alias

Returns whether tp is an instance or a refined instance of:

• scala.FunctionN
• scala.ContextFunctionN
• PolyFunction

Is synthesized symbol with alphanumeric name allowed to be used as an infix operator?

Is tp (an alias) of either a scala.FunctionN or a scala.ContextFunctionN instance?

Is a function class where

• FunctionN for N >= 0 and N != XXL

If the Single Abstract Method of a Function class has this type, is it specializable?

Is a synthetic function class

• FunctionN for N > 22
• ContextFunctionN for N >= 0

Is this type a TupleN type?

Is either FunctionXXL or a class that will be erased to FunctionXXL

• FunctionXXL
• FunctionN for N >= 22
• ContextFunctionN for N >= 22

If sym is a patched library class, the source file of its patch class, otherwise NoSource

A finalizer that patches standard library classes. It copies all non-private, non-synthetic definitions from patchCls to denot while changing their owners to denot. Before that it deletes any definitions of denot that have the same name as one of the copied definitions.

If an object is present in both the original class and the patch class, it is not overwritten. Instead its members are copied recursively.

To avpid running into cycles on bootstrap, patching happens only if patchCls is read from a classfile.

Lazy references to the root imports

Root types imported by default

If cls is a class in the scala package, its name, otherwise EmptyTypeName

If type ref refers to a class in the scala package, its name, otherwise EmptyTypeName

The JVM tag for tp if it's a primitive, java.lang.Object otherwise.

Modules whose members are in the default namespace and their module classes

Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter) because after erasure the Any and AnyVal references get remapped to the Object methods which would result in a double binding assertion failure. Instead we do the following:

• Have some methods exist only in Any, and remap them with the Erasure denotation transformer to be owned by Object.
• Have other methods exist only in Object. To achieve this, we synthesize all Any and Object methods; Object methods no longer get loaded from a classfile.

def getClassA >: this.type: Class[? <: A]

A type alias of Object used to represent any reference to Object in a Java signature, the secret sauce is that subtype checking treats it specially:

tp <:< FromJavaObject

is equivalent to:

tp <:< Any

This is useful to avoid usability problems when interacting with Java code where Object is the top type. This is safe because this type will only appear in signatures of Java definitions in positions where Object might appear, let's enumerate all possible cases this gives us:

1. At the top level:

   // A.java void meth1(Object arg) {} void meth2(T arg) {} // T implicitly extends Object

   // B.scala meth1(1) // OK meth2(1) // OK

   This is safe even though Int is not a subtype of Object, because Erasure will detect the mismatch and box the value type.

2. In a class type parameter:

   // A.java void meth3(scala.List