Retract arguments that were inferred to Nothing because inference failed. Correct types for repeated params.

We detect Nothing-due-to-failure by only retracting a parameter if either:

• it occurs in an invariant/contravariant position in restpe
• restpe == WildcardType

Retracted parameters are mapped to None. TODO:

• make sure the performance hit of storing these in a map is acceptable (it's going to be a small map in 90% of the cases, I think)
• refactor further up the callstack so that we don't have to do this post-factum adjustment?

Rewrite for repeated param types: Map T* entries to Seq[T].

Check that sym is defined and accessible as a member of tree site with type pre in current context.

TODO: much better error positions. Kind of stuck right now because they just pass us the one tree. TODO: Eliminate inPattern, canRemedy, which have no place here.

Instead of the canRemedy flag, annotate uncheckable types that have become checkable because of the availability of a class tag?

Substitute free type variables undetparams of polymorphic argument expression tree, given two prototypes strictPt, and lenientPt. strictPt is the first attempt prototype where type parameters are left unchanged. lenientPt is the fall-back prototype where type parameters are replaced by WildcardTypes. We try to instantiate first to strictPt and then, if this fails, to lenientPt. If both attempts fail, an error is produced.

Substitute free type variables undetparams of type constructor tree in pattern, given prototype pt.

Assign tree the symbol and type of the alternative which matches prototype pt, if it exists. If several alternatives match pt, take parameterless one. If no alternative matches pt, take the parameterless one anyway. (There may be more than one parameterless alternative, in particular, badly overloaded default args or case class elements. These are detected elsewhere.)

Infer type arguments targs for tparams of polymorphic expression in tree, given prototype pt.

Substitute tparams to targs in tree, after adjustment by adjustTypeArgs, returning the type parameters that were not determined If passed, infers against specified type treeTp instead of tree.tp.

Assign tree the type of an alternative which is applicable to argtpes, and whose result type is compatible with pt. If several applicable alternatives exist, drop the alternatives which use default arguments, then select the most specialized one. If no applicable alternative exists, and pt != WildcardType, try again with pt = WildcardType. Otherwise, if there is no best alternative, error.

Substitute free type variables undetparams of application fn(args), given prototype pt.

Assign tree the type of all polymorphic alternatives which have the same number of type parameters as does argtypes with all argtypes are within the corresponding type parameter bounds. If no such polymorphic alternative exist, error.

Type intersection of simple type tp1 with general type tp2. The result eliminates some redundancies.

Is type ftpe1 strictly more specific than type ftpe2 when both are alternatives in an overloaded function?

Return inferred type arguments, given type parameters, formal parameters, argument types, result type and expected result type. If this is not possible, throw a NoInstance exception. Undetermined type arguments are represented by definitions.NothingTpe. No check that inferred parameters conform to their bounds is made here.

Return inferred proto-type arguments of function, given its type and value parameters and result type, and a prototype pt for the function result. Type arguments need to be either determined precisely by the prototype, or they are maximized, if they occur only covariantly in the value parameter list. If instantiation of a type parameter fails, take WildcardType for the proto-type argument.

If the argument list needs to be tupled for the parameter list, a list containing the type of the tuple. Otherwise, the original argument list.

NOTE: we have to exclude repeated parameter types for overloading resolution like this: def f[T](x: T): T = x def f[T](x: T, xs: T*): T = x

In the process of deciding which ones is more specific, isApplicableToMethod would otherwise try T' = (T, T*)