if (isGenericTupleType(t)) {

return instantiateMappedGenericTupleType(t, type, typeVariable, mapper);

}

return instantiateMappedTupleType(t, type, prependTypeMapping(typeVariable, t, mapper));

function instantiateMappedGenericTupleType(tupleType: TupleTypeReference, mappedType: MappedType, typeVariable: TypeVariable, mapper: TypeMapper) {

// When a tuple type is generic (i.e. when it contains variadic elements), we want to eagerly map the

// non-generic elements and defer mapping the generic elements. In order to facilitate this, we transform

// M<[A, B?, ...T, ...C[]] into [...M<[A]>, ...M<[B?]>, ...M<T>, ...M<C[]>] and then rely on tuple type

// normalization to resolve the non-generic parts of the resulting tuple.

const elementTypes = map(getElementTypes(tupleType), (t, i) => {

const singleton = elementFlags[i] & ElementFlags.Variadic ? t :

elementFlags[i] & ElementFlags.Rest ? createArrayType(t) :

createTupleType([t], [elementFlags[i]]);

// avoid infinite recursion, if the singleton is the type variable itself

// then we'd just get back here with the same arguments from within instantiateMappedType

if (singleton === typeVariable) {

return mappedType;

}

// The singleton is never a generic tuple type, so it is safe to recurse here.

return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));

return createTupleType(elementTypes, map(elementTypes, _ => ElementFlags.Variadic), newReadonly);

function instantiateMappedTupleType(tupleType: TupleTypeReference, mappedType: MappedType, mapper: TypeMapper) {

const elementFlags = tupleType.target.elementFlags;

const elementTypes = map(getElementTypes(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & ElementFlags.Optional), mapper));

const modifiers = getMappedTypeModifiers(mappedType);

const newTupleModifiers = modifiers & MappedTypeModifiers.IncludeOptional ? map(elementFlags, f => f & ElementFlags.Required ? ElementFlags.Optional : f) :

modifiers & MappedTypeModifiers.ExcludeOptional ? map(elementFlags, f => f & ElementFlags.Optional ? ElementFlags.Required : f) :

elementFlags;

const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);

return contains(elementTypes, errorType) ? errorType :

createTupleType(elementTypes, newTupleModifiers, newReadonly, tupleType.target.labeledElementDeclarations);

}

const elementTypes = node.elements;

for (const e of elementTypes) {

const flags = getTupleElementFlags(e);

seenRestElement = true;

else if (flags & ElementFlags.Rest) {

else if (seenOptionalElement) {

>{ bar: "abc" } : { bar: "abc"; }

>bar : "abc"