Applications

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

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.

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

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

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

Compare owner inheritance level.

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.

The typed application

() or

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

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?

Is given method reference applicable to argument trees args?

Is given method reference applicable to argument types args?

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

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

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

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.

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.

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.

Drop any implicit parameter section

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

Typecheck application. Result could be an Apply node, or, if application is an operator assignment, also an Assign or Block node.

A typed unapply hook, can be overridden by re any-typers between frontend and pattern matcher.

If tree is a complete application of a compiler-generated apply or copy method of an enum case, widen its type to the underlying type by means of a type ascription, as long as the widened type is still compatible with the expected type. The underlying type is the intersection of all class parents of the orginal type.

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.

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.

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

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

Is there an implicit conversion from tp to pt?