Method getInferredType

internal/checker/inference.go:1283–1370

(n *InferenceContext, index int)

}

func (c *Checker) getInferredType(n *InferenceContext, index int) *Type {
	inference := n.inferences[index]
	if inference.inferredType == nil {
		if inference.typeParameter == c.errorType {
			return inference.typeParameter
		}
		var inferredType *Type
		var fallbackType *Type
		if n.signature != nil {
			var inferredCovariantType *Type
			if len(inference.candidates) != 0 {
				inferredCovariantType = c.getCovariantInference(inference, n.signature)
			}
			var inferredContravariantType *Type
			if len(inference.contraCandidates) != 0 {
				inferredContravariantType = c.getContravariantInference(inference)
			}
			if inferredCovariantType != nil || inferredContravariantType != nil {
				// If we have both co- and contra-variant inferences, we prefer the co-variant inference if it is not 'never',
				// all co-variant inferences are assignable to it (i.e. it isn't one of a conflicting set of candidates), it is
				// assignable to some contra-variant inference, and no other type parameter is constrained to this type parameter
				// and has inferences that would conflict. Otherwise, we prefer the contra-variant inference.
				// Similarly ignore co-variant `any` inference when both are available as almost everything is assignable to it
				// and it would spoil the overall inference.
				preferCovariantType := inferredCovariantType != nil && (inferredContravariantType == nil ||
					inferredCovariantType.flags&(TypeFlagsNever|TypeFlagsAny) == 0 &&
						core.Some(inference.contraCandidates, func(t *Type) bool { return c.isTypeAssignableTo(inferredCovariantType, t) }) &&
						core.Every(n.inferences, func(other *InferenceInfo) bool {
							return other != inference && c.getConstraintOfTypeParameter(other.typeParameter) != inference.typeParameter ||
								core.Every(other.candidates, func(t *Type) bool { return c.isTypeAssignableTo(t, inferredCovariantType) })
						}))
				if preferCovariantType {
					inferredType = inferredCovariantType
					fallbackType = inferredContravariantType
				} else {
					inferredType = inferredContravariantType
					fallbackType = inferredCovariantType
				}
			} else if n.flags&InferenceFlagsNoDefault != 0 {
				// We use silentNeverType as the wildcard that signals no inferences.
				inferredType = c.silentNeverType
			} else {
				// Infer either the default or the empty object type when no inferences were
				// made. It is important to remember that in this case, inference still
				// succeeds, meaning there is no error for not having inference candidates. An
				// inference error only occurs when there are *conflicting* candidates, i.e.
				// candidates with no common supertype.
				defaultType := c.getDefaultFromTypeParameter(inference.typeParameter)
				if defaultType != nil {
					// Instantiate the default type. Any forward reference to a type
					// parameter should be instantiated to the empty object type.
					inferredType = c.instantiateType(defaultType, mergeTypeMappers(c.newBackreferenceMapper(n, index), n.nonFixingMapper))
				}
			}
		} else {
			inferredType = c.getTypeFromInference(inference)
		}
		inference.inferredType = inferredType