ProtoTypes

A prototype for expressions [] that are known to be functions:

[] _

A prototype for expressions [] that are in some unspecified selection operation

[].?: ?

Used to indicate that expression is in a context where the only valid operation is further selection. In this case, the expression need not be a value.

A prototype for type constructors that are followed by a type application

A trait defining an isCompatible method.

A prototype for expressions that appear in function position

: resultType

A prototype for expressions that appear in function position

: resultType, where args are known to be typed

A class marking ignored prototypes that can be revealed by deepenProto

A trait for prototypes that match all types

A prototype for expressions [] that are type-parameterized:

[] [targs] resultType

A prototype for expressions [] that are part of a selection operation:

 [ ].name: proto

A prototype for selections in pattern constructors

A prototype for implicitly inferred views:

[]: argType => resultType

Dummy tree to be used as an argument of a FunProto or ViewProto type

Add all parameters of given type lambda tl to the constraint's domain. If the constraint contains already some of these parameters in its domain, make a copy of the type lambda and add the copy's type parameters instead. Return either the original type lambda, or the copy, if one was made. Also, if owningTree is non-empty or alwaysAddTypeVars is true, add a type variable for each parameter.

Same as constrained(tl, EmptyTree), but returns just the created type lambda

Instantiate tl with fresh type variables added to the constraint.

Create a new TypeVar that represents a dependent method parameter singleton ref

A fresh type variable added to the current constraint.

The normalized form of a type

• instantiate polymorphic types with fresh type variables in the current constraint
• skips implicit parameters of methods and functions; if result type depends on implicit parameter, replace with wildcard.
• converts non-dependent method types to the corresponding function types unless the expected type is an ApplyingProto or IgnoredProto.
• dereferences parameterless method types
• dereferences nullary method types provided the corresponding function type is not a subtype of the expected type. Note: We need to take account of the possibility of inserting a () argument list in normalization. Otherwise, a type with a def toString(): String member would not count as a valid solution for ?{toString: String}. This would then lead to an implicit insertion, with a nice explosion of inference search because of course every implicit result has some sort of toString method. The problem is solved by dereferencing nullary method types if the corresponding function type is not compatible with the prototype.

If param was created using newTypeVar(..., represents = X), returns X. This is used in:

• Inferencing#constrainIfDependentParamRef to retrieve the dependent function parameter for which the variable was substituted.
• ConstraintHandling#LevelAvoidMap#legalVar to retrieve the type variable that was avoided in a previous call to legalVar.

The result type of mt, where all references to parameters of mt are replaced by either wildcards or TypeParamRefs.

Create a selection proto-type, but only one level deep; treat constructors specially