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.

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.

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 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 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, 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 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 all type members of tp have realizable bounds

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 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

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.

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.

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?

Index symbols in tree 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.

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.

Substitute argument type argType for parameter pref in type tp, skolemizing the argument type if it is not stable and pref occurs in tp.

Substitute types of all arguments args for corresponding params in tp. The number of parameters params may exceed the number of arguments. In this case, only the common prefix is substituted.

Does state contain a "NotAMember" or "MissingIdent" message as first pending error message? That message would be $memberName is not a member of ... or Not found: $memberName. If memberName is empty, any name will do.

The type of the selection tree, where qual1 is the typed qualifier part.

Drop any implicit parameter section

If tree's type is a TermRef identified by flow typing to be non-null, then cast away trees nullability. Otherwise, tree remains unchanged.

Example: If x is a trackable reference and we know x is not null at this point, (x: T | Null) => x.$asInstanceOf$[x.type & T]

Try op1, if there are errors, try op2, if op2 also causes errors, fall back to errors and result of op1.

Assuming methodRef is a reference to an extension method defined e.g. as

extension [T1, T2](using A)(using B, C)(receiver: R)(using D) def foo[T3](using E)(f: F): G = ???

return the tree representing methodRef partially applied to the receiver and all the implicit parameters preceding it (A, B, C) with the type parameters of the extension (T1, T2) inferred. None is returned if the implicit search fails for any of the leading implicit parameters or if the receiver has a wrong type (note that in general the type of the receiver might depend on the exact types of the found instances of the proceding implicits). No implicit search is tried for implicits following the receiver or for parameters of the def (D, E).

Given a selection qual.name, try to convert to an extension method application name(qual) or insert an implicit conversion c(qual).name.

If this tree is a select node qual.name that does not conform to pt, try to insert an implicit conversion c around qual so that c(qual).name conforms to pt.

For a typed tree e: T, if T is an abstract type for which an implicit type test or class tag tt exists, rewrite to tt(e).

Normalize type T appearing in a new T by following eta expansions to avoid higher-kinded types.

Typecheck and adapt tree, returning a typed tree. Parameters as for typedUnadapted

Typecheck tree during completion using typed, and remember result in TypedAhead map

Types a splice applied to some arguments $f(arg1, ..., argn) in a quote pattern.

The tree is desugared into $f.apply(arg1, ..., argn) where the expression $f is expected to type as a function type (T1, ..., Tn) => R. Ti is the type of the argument argi and R if the type of the prototype. The prototype must be fully defined to be able to infer the type of R.

Type a case.

Special typing of Match tree when the expected type is a MatchType, and the patterns of the Match tree and the MatchType correspond.

Translate selection that does not typecheck according to the normal rules into a applyDynamic/applyDynamicNamed. foo.bar(baz0, baz1, ...) ~~> foo.applyDynamic(bar)(baz0, baz1, ...) foo.bar[T0, ...](baz0, baz1, ...) ~~> foo.applyDynamicT0, ...(baz0, baz1, ...) foo.bar(x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...) foo.bar[T0, ...](x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamedT0, ...(("x", bazX), ("y", bazY), ("", baz), ...)

Translate selection that does not typecheck according to the normal rules into a updateDynamic. foo.bar = baz ~~> foo.updateDynamic(bar)(baz)

Translate selection that does not typecheck according to the normal rules into a selectDynamic. foo.bar ~~> foo.selectDynamic(bar) foo.bar[T0, ...] ~~> foo.selectDynamicT0, ...

Note: inner part of translation foo.bar(baz) = quux ~~> foo.selectDynamic(bar).update(baz, quux) is achieved through an existing transformation of in typedAssign [foo.bar(baz) = quux ~~> foo.bar.update(baz, quux)].

Try to typecheck an implicit reference

Translate infix operation expression l op r to

l.op(r) if op is left-associative { val x = l; r.op(x) } if op is right-associative call-by-value and l is impure r.op(l) if op is right-associative call-by-name or l is pure

Translate infix type l op r to op[l, r] Translate infix pattern l op r to op(l, r)

Translate '{ e } into scala.quoted.Expr.apply(e) and '[T] into scala.quoted.Type.apply[T] while tracking the quotation level in the context.

Type a pattern variable name t in quote pattern as ${given t$giveni: Type[t @ _]}. The resulting pattern is the split in splitQuotePattern.

Translate ${ t: Expr[T] } into expression t.splice while tracking the quotation level in the context