Method createNormalizedTupleTypeEx

internal/checker/checker.go:23211–23257

(target *Type, elementTypes []*Type, objectFlags ObjectFlags)

}

func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type, objectFlags ObjectFlags) *Type {
	d := target.AsTupleType()
	if d.combinedFlags&ElementFlagsNonRequired == 0 {
		// No need to normalize when we only have regular required elements
		return c.createTypeReferenceEx(target, elementTypes, objectFlags)
	}
	if d.combinedFlags&ElementFlagsVariadic != 0 {
		for i, e := range elementTypes {
			if i < len(d.elementInfos) && d.elementInfos[i].flags&ElementFlagsVariadic != 0 && e.flags&(TypeFlagsNever|TypeFlagsUnion) != 0 {
				// Transform [A, ...(X | Y | Z)] into [A, ...X] | [A, ...Y] | [A, ...Z]
				checkTypes := core.MapIndex(elementTypes, func(t *Type, i int) *Type {
					if i < len(d.elementInfos) && d.elementInfos[i].flags&ElementFlagsVariadic != 0 {
						return t
					}
					return c.unknownType
				})
				if c.checkCrossProductUnion(checkTypes) {
					return c.mapType(e, func(t *Type) *Type {
						return c.createNormalizedTupleTypeEx(target, core.ReplaceElement(elementTypes, i, t), objectFlags)
					})
				}
			}
		}
	}
	// We have optional, rest, or variadic elements that may need normalizing. Normalization ensures that all variadic
	// elements are generic and that the tuple type has one of the following layouts, disregarding variadic elements:
	// (1) Zero or more required elements, followed by zero or more optional elements, followed by zero or one rest element.
	// (2) Zero or more required elements, followed by a rest element, followed by zero or more required elements.
	// In either layout, zero or more generic variadic elements may be present at any location.
	// Note that the element types may contain an extra 'this' type argument that we want to ignore during normalization
	// and then just append to the normalized element types.
	n := &TupleNormalizer{}
	if !n.normalize(c, elementTypes[:len(d.elementInfos)], d.elementInfos) {
		return c.errorType
	}
	if len(elementTypes) > len(d.elementInfos) {
		n.types = append(n.types, elementTypes[len(d.elementInfos)])
	}
	tupleTarget := c.getTupleTargetType(n.infos, d.readonly)
	switch {
	case tupleTarget == c.emptyGenericType:
		return c.emptyObjectType
	case len(n.types) != 0:
		return c.createTypeReferenceEx(tupleTarget, n.types, objectFlags)
	}
	return tupleTarget
}

func (c *Checker) createNormalizedTupleType(target *Type, elementTypes []*Type) *Type {
	return c.createNormalizedTupleTypeEx(target, elementTypes, ObjectFlagsNone)