const arity = getTypeReferenceArity(type);

const tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);

if (tupleConstituentNodes) {

tupleConstituentNodes[i] = factory.createNamedTupleMember(

flags & ElementFlags.Variable ? factory.createToken(SyntaxKind.DotDotDotToken) : undefined,

flags & ElementFlags.Optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined,

flags & ElementFlags.Rest ? factory.createArrayTypeNode(tupleConstituentNodes[i]) :

tupleConstituentNodes[i]

);

}

tupleConstituentNodes[i] =

flags & ElementFlags.Variable ? factory.createRestTypeNode(flags & ElementFlags.Rest ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]) :

flags & ElementFlags.Optional ? factory.createOptionalTypeNode(tupleConstituentNodes[i]) :

function getExpandedParameters(sig: Signature, skipUnionExpanding?: boolean): readonly (readonly Symbol[])[] {

if (signatureHasRestParameter(sig)) {

const restIndex = sig.parameters.length - 1;

const restType = getTypeOfSymbol(sig.parameters[restIndex]);

if (isTupleType(restType)) {

}

else if (!skipUnionExpanding && restType.flags & TypeFlags.Union && every((restType as UnionType).types, isTupleType)) {

}

}

return [sig.parameters];

const restParams = map(elementTypes, (t, i) => {

// Lookup the label from the individual tuple passed in before falling back to the signature `rest` parameter name

const name = associatedNames && associatedNames[i] ? associatedNames[i] :

return concatenate(sig.parameters.slice(0, restIndex), restParams);

}

const associatedNamesMap = new Map<__String, number>();

const prevCounter = associatedNamesMap.get(name);

if (prevCounter === undefined) {

associatedNamesMap.set(name, 1);

return readonly ? globalReadonlyArrayType : globalArrayType;

}

const elementFlags = map((node as TupleTypeNode).elements, getTupleElementFlags);

}

// Return true if the given type reference node is directly aliased or if it needs to be deferred

return isTypeOperatorNode(node) && node.operator === SyntaxKind.ReadonlyKeyword;

}

const tupleTarget = getTupleTargetType(elementFlags || map(elementTypes, _ => ElementFlags.Required), readonly, namedMemberDeclarations);

return tupleTarget === emptyGenericType ? emptyObjectType :

elementTypes.length ? createNormalizedTypeReference(tupleTarget, elementTypes) :

tupleTarget;

}

if (elementFlags.length === 1 && elementFlags[0] & ElementFlags.Rest) {

// [...X[]] is equivalent to just X[]

return readonly ? globalReadonlyArrayType : globalArrayType;

}

const key = map(elementFlags, f => f & ElementFlags.Required ? "#" : f & ElementFlags.Optional ? "?" : f & ElementFlags.Rest ? "." : "*").join() +

(readonly ? "R" : "") +

let type = tupleTypes.get(key);

if (!type) {

tupleTypes.set(key, type = createTupleTargetType(elementFlags, readonly, namedMemberDeclarations));

//

// Note that the generic type created by this function has no symbol associated with it. The same

// is true for each of the synthesized type parameters.

const arity = elementFlags.length;

const minLength = countWhere(elementFlags, f => !!(f & (ElementFlags.Required | ElementFlags.Variadic)));

let typeParameters: TypeParameter[] | undefined;

// In either layout, zero or more generic variadic elements may be present at any location.

const expandedTypes: Type[] = [];

const expandedFlags: ElementFlags[] = [];

let lastRequiredIndex = -1;

let firstRestIndex = -1;

let lastOptionalOrRestIndex = -1;

(t, i) => expandedFlags[firstRestIndex + i] & ElementFlags.Variadic ? getIndexedAccessType(t, numberType) : t));

expandedTypes.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);

expandedFlags.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);

}

const tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations);

return tupleTarget === emptyGenericType ? emptyObjectType :

}

expandedTypes.push(flags & ElementFlags.Optional ? addOptionality(type, /*isProperty*/ true) : type);

expandedFlags.push(flags);

}

}

return type;

}

Debug.assert(isIdentifier(d.name)); // Parameter declarations could be binding patterns, but we only allow identifier names

return d.name.escapedText;

}

if (isTupleType(restType)) {

const associatedNames = ((restType as TypeReference).target as TupleType).labeledElementDeclarations;

const index = pos - paramCount;

}

return restParameter.escapedName;

}

const elementTypes = node.elements;

let seenOptionalElement = false;

let seenRestElement = false;

for (const e of elementTypes) {

const flags = getTupleElementFlags(e);

if (flags & ElementFlags.Variadic) {

const type = getTypeFromTypeNode((e as RestTypeNode | NamedTupleMember).type);

"category": "Error",

"code": 5083

},

"A tuple member cannot be both optional and rest.": {

"category": "Error",

"code": 5085

hasRestElement: boolean;

combinedFlags: ElementFlags;

readonly: boolean;

export interface TupleTypeReference extends TypeReference {

hasRestElement: boolean;

combinedFlags: ElementFlags;

readonly: boolean;

}

interface TupleTypeReference extends TypeReference {

target: TupleType;

hasRestElement: boolean;

combinedFlags: ElementFlags;

readonly: boolean;

}

interface TupleTypeReference extends TypeReference {

target: TupleType;

>args : T

type T06 = T05<[number, ...boolean[]]>;

type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any ? { head: A, tail: B } : any[];

>P1 : P1<T>

function ff3<A extends unknown[]>(s1: (...args: [x: string, ...rest: A | [number]]) => void, s2: (x: string, ...rest: A | [number]) => void) {

>ff3 : <A extends unknown[]>(s1: (...args: [x: string, ...rest: A | [number]]) => void, s2: (x: string, ...rest: A | [number]) => void) => void

>s1 : (...args: [x: string, ...rest: A | [number]]) => void

>s2 : (x: string, ...rest: A | [number]) => void

>x : string

>rest : [number] | A

s1 = s2;

>s1 = s2 : (x: string, ...rest: [number] | A) => void

>s2 : (x: string, ...rest: [number] | A) => void

s2 = s1;

>s2 : (x: string, ...rest: [number] | A) => void

}

: never;

type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: 2[]]>;

type SubTup2TrailingVariadic<T extends unknown[]> = T extends [

>SubTup2TrailingVariadic : SubTup2TrailingVariadic<T>

: never;

type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: 0[], b: 1, c: 2]>;

type SubTup2VariadicWithLeadingFixedElements<T extends unknown[]> = T extends [

>SubTup2VariadicWithLeadingFixedElements : SubTup2VariadicWithLeadingFixedElements<T>