Typer

Subclass of Application for applicability tests with type arguments and value argument trees.

Subclass of Application for applicability tests with value argument types.

Subclass of Application for type checking an Apply node with typed arguments.

Subclass of Application for type checking an Apply node with untyped arguments.

The degree to which an argument has to match a formal parameter

The completer of a symbol defined by a member def or import (except ClassSymbols)

A helper class to derive type class instances for one class or object

An implicit search; parameters as in inferImplicit

Subclass of Application for the cases where we are interested only in a "can/cannot apply" answer, without needing to construct trees or issue error messages.

Subclass of Application for type checking an Apply node, where types of arguments are either known or unknown.

Perform the following adaptations of expression, pattern or type tree wrt to given prototype pt: (1) Resolve overloading (2) Apply parameterless functions (3) Apply polymorphic types to fresh instances of their type parameters and store these instances in context.undetparams, unless followed by explicit type application. (4) Do the following to unapplied methods used as values: (4.1) If the method has only implicit parameters pass implicit arguments (4.2) otherwise, if pt is a function type and method is not a constructor, convert to function by eta-expansion, (4.3) otherwise, if the method is nullary with a result type compatible to pt and it is not a constructor, apply it to () otherwise issue an error (5) Convert constructors in a pattern as follows: (5.1) If constructor refers to a case class factory, set tree's type to the unique instance of its primary constructor that is a subtype of the expected type. (5.2) If constructor refers to an extractor, convert to application of unapply or unapplySeq method.

(6) Convert all other types to TypeTree nodes. (7) When in TYPEmode but not FUNmode or HKmode, check that types are fully parameterized (7.1) In HKmode, higher-kinded types are allowed, but they must have the expected kind-arity (8) When in both EXPRmode and FUNmode, add apply method calls to values of object type. (9) If there are undetermined type variables and not POLYmode, infer expression instance Then, if tree's type is not a subtype of expected type, try the following adaptations: (10) If the expected type is Byte, Short or Char, and the expression is an integer fitting in the range of that type, convert it to that type. (11) Widen numeric literals to their expected type, if necessary (12) When in mode EXPRmode, convert E to { E; () } if expected type is scala.Unit. (13) When in mode EXPRmode, apply AnnotationChecker conversion if expected type is annotated. (14) When in mode EXPRmode, apply a view If all this fails, error Parameters as for typedUnadapted.

Checks that the given tree has been typed

Interpolate and simplify the type of the given tree.

Besides normal typing, this method does uncurrying and collects parameters to anonymous functions of arity > 22.

Besides normal typing, this function also compacts anonymous functions with more than MaxImplementedFunctionArity parameters to use a single parameter of type []Object.

Attribute an identifier consisting of a simple name or wildcard

Type check select nodes, applying the following rewritings exhaustively on selections e.m, where OT is the type of the owner of m and ET is the erased type of the selection's original qualifier expression.

e.m1 -> e.m2          if `m1` is a member of a class that erases to Object and `m2` is
                      the same-named member in Object.
e.m -> box(e).m       if `e` is primitive and `m` is a member or a reference class
                      or `e` has an erased value class type.
e.m -> unbox(e).m     if `e` is not primitive and `m` is a member of a primtive type.
e.m -> cast(e, OT).m  if the type of `e` does not conform to OT and `m`
                      is not an array operation.

If m is an array operation, i.e. one of the members apply, update, length, clone, and of class Array, we additionally try the following rewritings:

e.m -> runtime.array_m(e)   if ET is Object
e.m -> cast(e, ET).m        if the type of `e` does not conform to ET
e.clone -> e.clone'         where clone' is Object's clone method
e.m -> e.[]m                if `m` is an array operation other than `clone`.

When erasing most TypeTrees we should not semi-erase value types. This is not the case for DefDef#tpt, ValDef#tpt and Typed#tpt, they are handled separately by typedDefDef, typedValDef and typedTyped.

This override is only needed to semi-erase type ascriptions

Typecheck an Apply node with a typed function and possibly-typed arguments coming from proto

If tpe is a named type, return the type with those alternatives as denotations which are accessible (or NoType, if no alternatives are accessible).

Also performs the following normalizations on the type tpe. (1) if the owner of the denotation is a package object, it is assured that the package object shows up as the prefix. (2) in Java compilation units, Object is replaced by defn.FromJavaObjectType

Tries to adapt NotNullInfos from creation context to the DefTree, returns whether the adaption took place. An adaption only takes place if the DefTree has a symbol and it has not been completed (is not forward referenced).

Add givens reflecting CanThrow capabilities for all checked exceptions matched by cases. The givens appear in nested blocks with earlier cases leading to more deeply nested givens. This way, given priority will be the same as pattern priority. The functionality is enabled if the experimental.saferExceptions language feature is enabled.

Add child annotation for child to annotations of cls. The annotation is added at the correct insertion point, so that Child annotations appear in reverse order of their start positions.

Add java enum constants

The context to be used for an annotation of mdef. This should be the context enclosing mdef, or if mdef defines a parameter the context enclosing the owner of mdef. Furthermore, we need to evaluate annotation arguments in an expression context, since classes defined in a such arguments should not be entered into the enclosing class.

If app is a this(...) constructor call, the this-call argument context, otherwise the current context.

Assign type of RefinedType. Refinements are typed as if they were members of refinement class refineCls.

Type assignment method. Each method takes as parameters

• an untpd.Tree to which it assigns a type,
• typed child trees it needs to access to cpmpute that type,
• any further information it needs to access to compute that type.

A CanEqual[T, U] instance is assumed

• if one of T, U is an error type, or
• if one of T, U is a subtype of the lifted version of the other, unless strict equality is set.

check that annotation annot is applicable to symbol sym

Check arguments of compiler-defined annotations

Check that equality tests between types ltp and rtp make sense

Check that case classes are not inherited by case classes.

Check that catch can generate a good CanThrow exception

Check that tp is a class type. Also, if traitReq is true, check that tp is a trait. Also, if stablePrefixReq is true and phase is not after RefChecks, check that class prefix is stable.

Verify classes extending AnyVal meet the requirements

1. Check that all case classes that extend scala.reflect.Enum are enum cases
2. Check that parameterised enum cases do not extend java.lang.Enum.
3. Check that only a static enum base class can extend java.lang.Enum.
4. Check that user does not implement an ordinal method in the body of an enum class.

Check that all references coming from enum cases in an enum companion object are legal.

Check that the firstParent for an enum case derives from the declaring enum class, if not, adds it as a parent after emitting an error.

This check will have no effect on simple enum cases as their parents are inferred by the compiler.

Check that tp is a class type and that any top-level type arguments in this type are feasible, i.e. that their lower bound conforms to their upper bound. If a type argument is infeasible, issue and error and continue with upper bound.

Issue a feature warning if feature is not enabled

Check that user-defined (result) type is fully applied

If sym is an old-style implicit conversion, check that implicit conversions are enabled.

If tree is an application of a new-style implicit conversion (using the apply method of a scala.Conversion instance), check that implicit conversions are enabled.

Check that we are in an inline context (inside an inline method or in inline code)

Check that pattern pat is irrefutable for scrutinee type sel.tpe. This means sel is either marked @unchecked or sel.tpe conforms to the pattern's type. If pattern is an UnApply, also check that the extractor is irrefutable, and do the check recursively.

Check that path is a legal prefix for an export clause

Check that path is a legal prefix for an import clause

Check that all named types that form part of this type have a denotation. Called on inferred (result) types of ValDefs and DefDefs. This could fail for types where the member was originally available as part of the self type, yet is no longer visible once the this has been replaced by some other prefix. See neg/i3083.scala

Check that a new definition with given name and privacy status in current context would not conflict with existing currently compiled definitions. The logic here is very subtle and fragile due to the fact that we are not allowed to force anything.

Check that class does not declare same symbol twice

Check that method parameter types do not reference their own parameter or later parameters in the same parameter section.

Check that module sym does not clash with a class of the same name that is concurrently compiled in another source file.

Check that symbol's external name does not clash with symbols defined in the same scope

Check that all type members of tp have realizable bounds

Check that all non-synthetic references of the form <ident> or this.<ident> in tree that refer to a member of badOwner are allowed. Also check that there are no other explicit this references to badOwner.

Check that tpt does not define a higher-kinded type

Check that type tp is stable.

Given a parent parent of a class cls, if parent is a trait check that the superclass of cls derived from the superclass of parent.

An exception is made if cls extends Any, and parent is java.io.Serializable or java.lang.Comparable. These two classes are treated by Scala as universal traits. E.g. the following is OK:

... extends Any with java.io.Serializable

The standard library relies on this idiom.

Check that tree is a valid infix operation. That is, if the operator is alphanumeric, it must be declared infix.

Compare to alternatives of an overloaded call or an implicit search.

Compare owner inheritance level.

Enter and typecheck parameter list

Constrain result with special case if meth is an inlineable method in an inlineable context. In that case, we should always succeed and not constrain type parameters in the expected type, because the actual return type can be a subtype of the currently known return type. However, we should constrain parameters of the declared return type. This distinction is achieved by replacing expected type parameters with wildcards.

Check that the result type of the current method fits the given expected result type.

Rewrite new Array[T](....) if T is an unbounded generic to calls to newGenericArray. It is performed during typer as creation of generic arrays needs a classTag. we rely on implicit search to find one.

If this tree is a member def or an import, create a symbol of it and store in symOfTree map.

The type signature of a DefDef with given symbol

The enclosing class with given name; error if none exists

Try to make tpe accessible, emit error if not possible

If this is a real class, make sure its first parent is a constructor call. Cannot simply use a type. Overridden in ReTyper.

If this is a real class, make sure its first parent is a constructor call. Cannot simply use a type. Overridden in ReTyper.

Ensure that the first type in a list of parent types Ps points to a non-trait class. If that's not already the case, add one. The added class type CT is determined as follows. First, let C be the unique class such that

• there is a parent P_i such that P_i derives from C, and
• for every class D: If some parent P_j, j <= i derives from D, then C derives from D. Then, let CT be the smallest type which
• has C as its class symbol, and
• for all parents P_i: If P_i derives from C then P_i <:< CT.

Tweak: It could be that at the point where the method is called, some superclass is still missing its parents. Parents are set to Nil when completion starts and are set to the actual parents later. If a superclass completes a subclass in one of its parents, the parents of the superclass or some intervening class might not yet be set. This situation can be detected by asking for the baseType of Any - if that type does not exist, one of the base classes of this class misses its parents. If this situation arises, the computation of the superclass might be imprecise. For instance, in i12722.scala, the superclass of IPersonalCoinOps is computed as Object, where JsObject would be correct. The problem cannot be solved locally, but we detect the situaton and mark the superclass with a @ProvisionalSuperClass annotation in this case. When typechecking the class, we then run ensureFirstIsClass again and possibly improve the computed super class. An alternatiev fix would compute superclasses at typer instead at completion. But that breaks too many invariants. For instance, we rely on correct @Child annotations after completion, and these in turn need the superclass.

If sym exists, enter it in effective scope. Check that package members are not entered twice in the same run.

A hook to exclude selected symbols from double declaration check

Expand tree and store in expandedTree

The expanded version of this tree, or tree itself if not expanded

The typed application

() or

where comes from pt if it is a (possibly ignored) PolyProto.

Find the type of an identifier with given name in given context ctx.

Handle reflection-based dispatch for members of structural types.

Given x.a, where x is of (widened) type T (a value type or a nullary method type), and x.a is of type U, map x.a to the equivalent of:

x1.selectDynamic("a").asInstanceOf[U]

where x1 is x adapted to Selectable.

Given x.a(a11, ..., a1n)...(aN1, ..., aNn), where x.a is of (widened) type (T11, ..., T1n)...(TN1, ..., TNn): R, it is desugared to:

x1.applyDynamic("a")(a11, ..., a1n, ..., aN1, ..., aNn)
  .asInstanceOf[R]

If this call resolves to an applyDynamic method that takes a Class[?]* as second parameter, we further rewrite this call to scala

x1.applyDynamic("a", c11, ..., c1n, ..., cN1, ... cNn)
                (a11, ..., a1n, ..., aN1, ..., aNn)
  .asInstanceOf[R]

where c11, ..., cNn are the classOf constants representing the erasures of T11, ..., TNn.

It's an error if U is neither a value nor a method type, or a dependent method type

Overridden in ReTyper to handle primitive operations that can be generated after erasure

Apply a transformation harmonize on the results of operation op, unless the expected type pt is fully defined. If the result is different (wrt eq) from the original results of op, revert back to the constraint in force before computing op. This reset is needed because otherwise the original results might have added constraints to type parameters which are no longer implied after harmonization. No essential constraints are lost by this because the result of harmomization will be compared again with the expected type. Test cases where this matters are in pos/harmomize.scala.

If trees all have numeric value types, and they do not have all the same type, pick a common numeric supertype and try to convert all constant Int literals to this type. If the resulting trees all have the same type, return them instead of the original ones.

Does tp have an extension method named xname with this-argument argType and result matching resultType?

True if this inline typer has already issued errors

Search an implicit argument and report error if not found

A string indicating the formal parameter corresponding to a missing argument

The type bound on wildcard imports of an import list, with special values Nothing if no wildcard imports of this kind exist Any if there are unbounded wildcard imports of this kind

An addendum to an error message where the error might be fixed by some implicit value of type pt that is however not found. The addendum suggests given imports that might fix the problem. If there's nothing to suggest, an empty string is returned.

Create top-level symbols for statements and enter them into symbol table

Expand tree and create top-level symbols for statement and enter them into symbol table

Create top-level symbols for all statements in the expansion of this statement and enter them into symbol table

Find an implicit parameter or conversion.

Find an implicit argument for parameter formal. Return a failure as a SearchFailureType in the type of the returned tree.

Find an implicit conversion to apply to given tree from so that the result is compatible with type to.

The parameter type for a parameter in a lambda that does not have an explicit type given, and where the type is not known from the context. In this case the parameter type needs to be inferred the "target type" T known from the callee f if the lambda is of a form like x => f(x). If T exists, we know that S <: I <: T.

The inference makes two attempts:

1. Compute the target type T and make it known that S <: T. If the expected type S can be fully defined under ForceDegree.flipBottom, pick this one (this might use the fact that S <: T for an upper approximation).
2. Otherwise, if the target type T can be fully defined under ForceDegree.flipBottom, pick this one.

If both attempts fail, return NoType.

Given an inline method mdef, the method rewritten so that its body uses accessors to access non-public members. Also, if the inline method is retained, add a method to record the retained version of the body. Overwritten in Retyper to return mdef unchanged.

If the prototype pt is the type lambda (when doing a dependent typing of a match), instantiate that type lambda with the pattern variables found in the pattern pat.

Interpolate undetermined type variables in the widened type of this tree.

For all class definitions stat in xstats: If the companion class is not also defined in xstats, invalidate it by setting its info to NoType.

Is given method reference applicable to argument types args?

Is given method reference applicable to argument trees args?

Is given type applicable to argument types args, possibly after inserting an apply?

Is given type applicable to argument trees args, possibly after inserting an apply?

Is pt a prototype of an apply selection, or a parameterless function yielding one?

A type tp is compatible with a type pt if one of the following holds:

1. tp is a subtype of pt
2. pt is by name parameter type, and tp is compatible with its underlying type
3. there is an implicit conversion from tp to pt.
4. tp is a numeric subtype of pt (this case applies even if implicit conversions are disabled) If pt is a by-name type, we compare against the underlying type instead.

Determines whether this field holds an enum constant.

Is tp a unary function type or an overloaded type with with only unary function types as alternatives?

Parse the source and index symbols in the compilation unit's untpdTree while asserting the lateCompile flag. This will cause any old top-level symbol with the same fully qualified name as a newly created symbol to be replaced.

Will call the callback with an implementation of type checking That will set the tpdTree and root tree for the compilation unit.

Return a potentially skolemized version of qualTpe to be used as a prefix when selecting name.

The signature of a module valdef. This will compute the corresponding module class TypeRef immediately without going through the defined type of the ValDef. This is necessary to avoid cyclic references involving imports and module val defs.

Like normalize and then isCompatible, but using a subtype comparison with necessary eithers that does not unnecessarily truncate the constraint space, returning false instead.

Should we tuple or untuple the argument before application? If auto-tupling is enabled then

• we tuple n-ary arguments where n > 0 if the function consists only of unary alternatives
• we untuple tuple arguments of infix operations if the function does not consist only of unary alternatives.

Test compatibility after normalization. If keepConstraint is false, the current constraint set will not be modified by this call.

The qualifying class of a this or super with prefix qual (which might be empty).

A denotation exists really if it exists and does not point to a stale symbol.

Record sym as the symbol defined by tree

Resolve overloading by mapping to a different problem where each alternative's type is mapped with f, alternatives with non-existing types are dropped, and the expected type is pt. Map the results back to the original alternatives.

Resolve overloaded alternative alts, given expected type pt. Two trials: First, without implicits or SAM conversions enabled. Then, if the first finds no eligible candidates, with implicits and SAM conversions enabled.