diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8b8a12fa72378..7bd58c379eac9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4564,17 +4564,32 @@ namespace ts { const tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context); const hasRestElement = (type.target).hasRestElement; if (tupleConstituentNodes) { - for (let i = (type.target).minLength; i < Math.min(arity, tupleConstituentNodes.length); i++) { - tupleConstituentNodes[i] = hasRestElement && i === arity - 1 ? - createRestTypeNode(createArrayTypeNode(tupleConstituentNodes[i])) : - createOptionalTypeNode(tupleConstituentNodes[i]); + if ((type.target as TupleType).labeledElementDeclarations) { + for (let i = 0; i < tupleConstituentNodes.length; i++) { + const isOptionalOrRest = i >= (type.target).minLength; + const isRest = isOptionalOrRest && hasRestElement && i === arity - 1; + const isOptional = isOptionalOrRest && !isRest; + tupleConstituentNodes[i] = createNamedTupleMember( + isRest ? createToken(SyntaxKind.DotDotDotToken) : undefined, + createIdentifier(unescapeLeadingUnderscores(getTupleElementLabel((type.target as TupleType).labeledElementDeclarations![i]))), + isOptional ? createToken(SyntaxKind.QuestionToken) : undefined, + isRest ? createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i] + ); + } + } + else { + for (let i = (type.target).minLength; i < Math.min(arity, tupleConstituentNodes.length); i++) { + tupleConstituentNodes[i] = hasRestElement && i === arity - 1 ? + createRestTypeNode(createArrayTypeNode(tupleConstituentNodes[i])) : + createOptionalTypeNode(tupleConstituentNodes[i]); + } } - const tupleTypeNode = createTupleTypeNode(tupleConstituentNodes); + const tupleTypeNode = setEmitFlags(createTupleTypeNode(tupleConstituentNodes), EmitFlags.SingleLine); return (type.target).readonly ? createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, tupleTypeNode) : tupleTypeNode; } } if (context.encounteredError || (context.flags & NodeBuilderFlags.AllowEmptyTuple)) { - const tupleTypeNode = createTupleTypeNode([]); + const tupleTypeNode = setEmitFlags(createTupleTypeNode([]), EmitFlags.SingleLine); return (type.target).readonly ? createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, tupleTypeNode) : tupleTypeNode; } context.encounteredError = true; @@ -4908,7 +4923,7 @@ namespace ts { typeParameters = signature.typeParameters && signature.typeParameters.map(parameter => typeParameterToDeclaration(parameter, context)); } - const parameters = getExpandedParameters(signature).map(parameter => symbolToParameterDeclaration(parameter, context, kind === SyntaxKind.Constructor, privateSymbolVisitor, bundledImports)); + const parameters = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0].map(parameter => symbolToParameterDeclaration(parameter, context, kind === SyntaxKind.Constructor, privateSymbolVisitor, bundledImports)); if (signature.thisParameter) { const thisParameter = symbolToParameterDeclaration(signature.thisParameter, context); parameters.unshift(thisParameter); @@ -5556,6 +5571,7 @@ namespace ts { cancellationToken.throwIfCancellationRequested(); } let hadError = false; + const file = getSourceFileOfNode(existing); const transformed = visitNode(existing, visitExistingNodeTreeSymbols); if (hadError) { return undefined; @@ -5684,6 +5700,10 @@ namespace ts { } } + if (file && isTupleTypeNode(node) && (getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line)) { + setEmitFlags(node, EmitFlags.SingleLine); + } + return visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext); function getEffectiveDotDotDotForParameter(p: ParameterDeclaration) { @@ -6944,7 +6964,7 @@ namespace ts { function getTypeAliasForTypeLiteral(type: Type): Symbol | undefined { if (type.symbol && type.symbol.flags & SymbolFlags.TypeLiteral) { - const node = findAncestor(type.symbol.declarations[0].parent, n => n.kind !== SyntaxKind.ParenthesizedType)!; + const node = walkUpParenthesizedTypes(type.symbol.declarations[0].parent); if (node.kind === SyntaxKind.TypeAliasDeclaration) { return getSymbolOfNode(node); } @@ -7132,6 +7152,7 @@ namespace ts { case SyntaxKind.UnionType: case SyntaxKind.IntersectionType: case SyntaxKind.ParenthesizedType: + case SyntaxKind.NamedTupleMember: return isDeclarationVisible(node.parent); // Default binding, import specifier and namespace import is visible @@ -9535,27 +9556,36 @@ namespace ts { return result; } - function getExpandedParameters(sig: Signature): readonly Symbol[] { + function getExpandedParameters(sig: Signature, skipUnionExpanding?: boolean): readonly (readonly Symbol[])[] { if (signatureHasRestParameter(sig)) { const restIndex = sig.parameters.length - 1; - const restParameter = sig.parameters[restIndex]; - const restType = getTypeOfSymbol(restParameter); + const restType = getTypeOfSymbol(sig.parameters[restIndex]); if (isTupleType(restType)) { - const elementTypes = getTypeArguments(restType); - const minLength = restType.target.minLength; - const tupleRestIndex = restType.target.hasRestElement ? elementTypes.length - 1 : -1; - const restParams = map(elementTypes, (t, i) => { - const name = getParameterNameAtPosition(sig, restIndex + i); - const checkFlags = i === tupleRestIndex ? CheckFlags.RestParameter : - i >= minLength ? CheckFlags.OptionalParameter : 0; - const symbol = createSymbol(SymbolFlags.FunctionScopedVariable, name, checkFlags); - symbol.type = i === tupleRestIndex ? createArrayType(t) : t; - return symbol; - }); - return concatenate(sig.parameters.slice(0, restIndex), restParams); - } + return [expandSignatureParametersWithTupleMembers(restType, restIndex)]; + } + else if (!skipUnionExpanding && restType.flags & TypeFlags.Union && every((restType as UnionType).types, isTupleType)) { + return map((restType as UnionType).types, t => expandSignatureParametersWithTupleMembers(t as TupleTypeReference, restIndex)); + } + } + return [sig.parameters]; + + function expandSignatureParametersWithTupleMembers(restType: TupleTypeReference, restIndex: number) { + const elementTypes = getTypeArguments(restType); + const minLength = restType.target.minLength; + const tupleRestIndex = restType.target.hasRestElement ? elementTypes.length - 1 : -1; + const associatedNames = restType.target.labeledElementDeclarations; + 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 tupleLabelName = !!associatedNames && getTupleElementLabel(associatedNames[i]); + const name = tupleLabelName || getParameterNameAtPosition(sig, restIndex + i); + const checkFlags = i === tupleRestIndex ? CheckFlags.RestParameter : + i >= minLength ? CheckFlags.OptionalParameter : 0; + const symbol = createSymbol(SymbolFlags.FunctionScopedVariable, name, checkFlags); + symbol.type = i === tupleRestIndex ? createArrayType(t) : t; + return symbol; + }); + return concatenate(sig.parameters.slice(0, restIndex), restParams); } - return sig.parameters; } function getDefaultConstructSignatures(classType: InterfaceType): Signature[] { @@ -11598,7 +11628,7 @@ namespace ts { const typeArguments = !node ? emptyArray : node.kind === SyntaxKind.TypeReference ? concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters!)) : node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] : - map(node.elementTypes, getTypeFromTypeNode); + map(node.elements, getTypeFromTypeNode); if (popTypeResolution()) { type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments; } @@ -11804,11 +11834,11 @@ namespace ts { } function isUnaryTupleTypeNode(node: TypeNode) { - return node.kind === SyntaxKind.TupleType && (node).elementTypes.length === 1; + return node.kind === SyntaxKind.TupleType && (node).elements.length === 1; } function getImpliedConstraint(type: Type, checkNode: TypeNode, extendsNode: TypeNode): Type | undefined { - return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, (checkNode).elementTypes[0], (extendsNode).elementTypes[0]) : + return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, (checkNode).elements[0], (extendsNode).elements[0]) : getActualTypeVariable(getTypeFromTypeNode(checkNode)) === type ? getTypeFromTypeNode(extendsNode) : undefined; } @@ -12104,15 +12134,24 @@ namespace ts { return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]); } + function isTupleRestElement(node: TypeNode) { + return node.kind === SyntaxKind.RestType || (node.kind === SyntaxKind.NamedTupleMember && !!(node as NamedTupleMember).dotDotDotToken); + } + + function isTupleOptionalElement(node: TypeNode) { + return node.kind === SyntaxKind.OptionalType || (node.kind === SyntaxKind.NamedTupleMember && !!(node as NamedTupleMember).questionToken); + } + function getArrayOrTupleTargetType(node: ArrayTypeNode | TupleTypeNode): GenericType { const readonly = isReadonlyTypeOperator(node.parent); - if (node.kind === SyntaxKind.ArrayType || node.elementTypes.length === 1 && node.elementTypes[0].kind === SyntaxKind.RestType) { + if (node.kind === SyntaxKind.ArrayType || node.elements.length === 1 && isTupleRestElement(node.elements[0])) { return readonly ? globalReadonlyArrayType : globalArrayType; } - const lastElement = lastOrUndefined(node.elementTypes); - const restElement = lastElement && lastElement.kind === SyntaxKind.RestType ? lastElement : undefined; - const minLength = findLastIndex(node.elementTypes, n => n.kind !== SyntaxKind.OptionalType && n !== restElement) + 1; - return getTupleTypeOfArity(node.elementTypes.length, minLength, !!restElement, readonly, /*associatedNames*/ undefined); + const lastElement = lastOrUndefined(node.elements); + const restElement = lastElement && isTupleRestElement(lastElement) ? lastElement : undefined; + const minLength = findLastIndex(node.elements, n => !isTupleOptionalElement(n) && n !== restElement) + 1; + const missingName = some(node.elements, e => e.kind !== SyntaxKind.NamedTupleMember); + return getTupleTypeOfArity(node.elements.length, minLength, !!restElement, readonly, /*associatedNames*/ missingName ? undefined : node.elements as readonly NamedTupleMember[]); } // Return true if the given type reference node is directly aliased or if it needs to be deferred @@ -12120,7 +12159,7 @@ namespace ts { function isDeferredTypeReferenceNode(node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode, hasDefaultTypeArguments?: boolean) { return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && ( node.kind === SyntaxKind.ArrayType ? mayResolveTypeAlias(node.elementType) : - node.kind === SyntaxKind.TupleType ? some(node.elementTypes, mayResolveTypeAlias) : + node.kind === SyntaxKind.TupleType ? some(node.elements, mayResolveTypeAlias) : hasDefaultTypeArguments || some(node.typeArguments, mayResolveTypeAlias)); } @@ -12131,6 +12170,7 @@ namespace ts { const parent = node.parent; switch (parent.kind) { case SyntaxKind.ParenthesizedType: + case SyntaxKind.NamedTupleMember: case SyntaxKind.TypeReference: case SyntaxKind.UnionType: case SyntaxKind.IntersectionType: @@ -12158,11 +12198,12 @@ namespace ts { return (node).operator !== SyntaxKind.UniqueKeyword && mayResolveTypeAlias((node).type); case SyntaxKind.ParenthesizedType: case SyntaxKind.OptionalType: + case SyntaxKind.NamedTupleMember: case SyntaxKind.JSDocOptionalType: case SyntaxKind.JSDocNullableType: case SyntaxKind.JSDocNonNullableType: case SyntaxKind.JSDocTypeExpression: - return mayResolveTypeAlias((node).type); + return mayResolveTypeAlias((node).type); case SyntaxKind.RestType: return (node).type.kind !== SyntaxKind.ArrayType || mayResolveTypeAlias(((node).type).elementType); case SyntaxKind.UnionType: @@ -12185,11 +12226,11 @@ namespace ts { links.resolvedType = emptyObjectType; } else if (isDeferredTypeReferenceNode(node)) { - links.resolvedType = node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : + links.resolvedType = node.kind === SyntaxKind.TupleType && node.elements.length === 0 ? target : createDeferredTypeReference(target, node, /*mapper*/ undefined); } else { - const elementTypes = node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] : map(node.elementTypes, getTypeFromTypeNode); + const elementTypes = node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] : map(node.elements, getTypeFromTypeNode); links.resolvedType = createTypeReference(target, elementTypes); } } @@ -12207,7 +12248,7 @@ namespace ts { // // 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. - function createTupleTypeOfArity(arity: number, minLength: number, hasRestElement: boolean, readonly: boolean, associatedNames: __String[] | undefined): TupleType { + function createTupleTypeOfArity(arity: number, minLength: number, hasRestElement: boolean, readonly: boolean, namedMemberDeclarations: readonly (NamedTupleMember | ParameterDeclaration)[] | undefined): TupleType { let typeParameters: TypeParameter[] | undefined; const properties: Symbol[] = []; const maxLength = hasRestElement ? arity - 1 : arity; @@ -12218,6 +12259,7 @@ namespace ts { if (i < maxLength) { const property = createSymbol(SymbolFlags.Property | (i >= minLength ? SymbolFlags.Optional : 0), "" + i as __String, readonly ? CheckFlags.Readonly : 0); + property.tupleLabelDeclaration = namedMemberDeclarations?.[i]; property.type = typeParameter; properties.push(property); } @@ -12247,25 +12289,25 @@ namespace ts { type.minLength = minLength; type.hasRestElement = hasRestElement; type.readonly = readonly; - type.associatedNames = associatedNames; + type.labeledElementDeclarations = namedMemberDeclarations; return type; } - function getTupleTypeOfArity(arity: number, minLength: number, hasRestElement: boolean, readonly: boolean, associatedNames?: __String[]): GenericType { - const key = arity + (hasRestElement ? "+" : ",") + minLength + (readonly ? "R" : "") + (associatedNames && associatedNames.length ? "," + associatedNames.join(",") : ""); + function getTupleTypeOfArity(arity: number, minLength: number, hasRestElement: boolean, readonly: boolean, namedMemberDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]): GenericType { + const key = arity + (hasRestElement ? "+" : ",") + minLength + (readonly ? "R" : "") + (namedMemberDeclarations && namedMemberDeclarations.length ? "," + map(namedMemberDeclarations, getNodeId).join(",") : ""); let type = tupleTypes.get(key); if (!type) { - tupleTypes.set(key, type = createTupleTypeOfArity(arity, minLength, hasRestElement, readonly, associatedNames)); + tupleTypes.set(key, type = createTupleTypeOfArity(arity, minLength, hasRestElement, readonly, namedMemberDeclarations)); } return type; } - function createTupleType(elementTypes: readonly Type[], minLength = elementTypes.length, hasRestElement = false, readonly = false, associatedNames?: __String[]) { + function createTupleType(elementTypes: readonly Type[], minLength = elementTypes.length, hasRestElement = false, readonly = false, namedMemberDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]) { const arity = elementTypes.length; if (arity === 1 && hasRestElement) { return createArrayType(elementTypes[0], readonly); } - const tupleType = getTupleTypeOfArity(arity, minLength, arity > 0 && hasRestElement, readonly, associatedNames); + const tupleType = getTupleTypeOfArity(arity, minLength, arity > 0 && hasRestElement, readonly, namedMemberDeclarations); return elementTypes.length ? createTypeReference(tupleType, elementTypes) : tupleType; } @@ -12280,7 +12322,7 @@ namespace ts { Math.max(0, tuple.minLength - index), tuple.hasRestElement, tuple.readonly, - tuple.associatedNames && tuple.associatedNames.slice(index), + tuple.labeledElementDeclarations && tuple.labeledElementDeclarations.slice(index), ); } @@ -13859,6 +13901,21 @@ namespace ts { return links.resolvedType; } + function getTypeFromNamedTupleTypeNode(node: NamedTupleMember): Type { + const links = getNodeLinks(node); + if (!links.resolvedType) { + let type = getTypeFromTypeNode(node.type); + if (node.dotDotDotToken) { + type = getElementTypeOfArrayType(type) || errorType; + } + if (node.questionToken && strictNullChecks) { + type = getOptionalType(type); + } + links.resolvedType = type; + } + return links.resolvedType; + } + function getTypeFromTypeNode(node: TypeNode): Type { return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node); } @@ -13917,10 +13974,12 @@ namespace ts { return getTypeFromJSDocNullableTypeNode(node); case SyntaxKind.JSDocOptionalType: return addOptionality(getTypeFromTypeNode((node as JSDocOptionalType).type)); + case SyntaxKind.NamedTupleMember: + return getTypeFromNamedTupleTypeNode(node as NamedTupleMember); case SyntaxKind.ParenthesizedType: case SyntaxKind.JSDocNonNullableType: case SyntaxKind.JSDocTypeExpression: - return getTypeFromTypeNode((node).type); + return getTypeFromTypeNode((node).type); case SyntaxKind.RestType: return getElementTypeOfArrayType(getTypeFromTypeNode((node).type)) || errorType; case SyntaxKind.JSDocVariadicType: @@ -14279,7 +14338,7 @@ namespace ts { minLength; const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers); return contains(elementTypes, errorType) ? errorType : - createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames); + createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.labeledElementDeclarations); } function instantiateMappedTypeTemplate(type: MappedType, key: Type, isOptional: boolean, mapper: TypeMapper) { @@ -18536,7 +18595,7 @@ namespace ts { const elementTypes = map(getTypeArguments(source), t => inferReverseMappedType(t, target, constraint)); const minLength = getMappedTypeModifiers(target) & MappedTypeModifiers.IncludeOptional ? getTypeReferenceArity(source) - (source.target.hasRestElement ? 1 : 0) : source.target.minLength; - return createTupleType(elementTypes, minLength, source.target.hasRestElement, source.target.readonly, source.target.associatedNames); + return createTupleType(elementTypes, minLength, source.target.hasRestElement, source.target.readonly, source.target.labeledElementDeclarations); } // For all other object types we infer a new object type where the reverse mapping has been // applied to the type of each property. @@ -25135,7 +25194,7 @@ namespace ts { function getArrayifiedType(type: Type) { return type.flags & TypeFlags.Union ? mapType(type, getArrayifiedType) : type.flags & (TypeFlags.Any | TypeFlags.Instantiable) || isMutableArrayOrTuple(type) ? type : - isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.minLength, type.target.hasRestElement, /*readonly*/ false, type.target.associatedNames) : + isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.minLength, type.target.hasRestElement, /*readonly*/ false, type.target.labeledElementDeclarations) : createArrayType(getIndexedAccessType(type, numberType)); } @@ -25151,6 +25210,7 @@ namespace ts { } } const types = []; + const names: (ParameterDeclaration | NamedTupleMember)[] = []; let spreadIndex = -1; for (let i = index; i < argCount; i++) { const contextualType = getIndexedAccessType(restType, getLiteralType(i - index)); @@ -25158,12 +25218,15 @@ namespace ts { if (spreadIndex < 0 && isSpreadArgument(args[i])) { spreadIndex = i - index; } + if (args[i].kind === SyntaxKind.SyntheticExpression && (args[i] as SyntheticExpression).tupleNameSource) { + names.push((args[i] as SyntheticExpression).tupleNameSource!); + } const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index); types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType)); } return spreadIndex < 0 ? - createTupleType(types) : - createTupleType(append(types.slice(0, spreadIndex), getUnionType(types.slice(spreadIndex))), spreadIndex, /*hasRestElement*/ true); + createTupleType(types, /*minLength*/ undefined, /*hasRestElement*/ undefined, /*readonly*/ undefined, length(names) === length(types) ? names : undefined) : + createTupleType(append(types.slice(0, spreadIndex), getUnionType(types.slice(spreadIndex))), spreadIndex, /*hasRestElement*/ true, /*readonly*/ undefined); } function checkTypeArguments(signature: Signature, typeArgumentNodes: readonly TypeNode[], reportErrors: boolean, headMessage?: DiagnosticMessage): Type[] | undefined { @@ -25414,11 +25477,12 @@ namespace ts { } } - function createSyntheticExpression(parent: Node, type: Type, isSpread?: boolean) { + function createSyntheticExpression(parent: Node, type: Type, isSpread?: boolean, tupleNameSource?: ParameterDeclaration | NamedTupleMember) { const result = createNode(SyntaxKind.SyntheticExpression, parent.pos, parent.end); result.parent = parent; result.type = type; result.isSpread = isSpread || false; + result.tupleNameSource = tupleNameSource; return result; } @@ -25453,7 +25517,7 @@ namespace ts { if (isTupleType(type)) { const typeArguments = getTypeArguments(type); const restIndex = type.target.hasRestElement ? typeArguments.length - 1 : -1; - const syntheticArgs = map(typeArguments, (t, i) => createSyntheticExpression(spreadArgument, t, /*isSpread*/ i === restIndex)); + const syntheticArgs = map(typeArguments, (t, i) => createSyntheticExpression(spreadArgument, t, /*isSpread*/ i === restIndex, type.target.labeledElementDeclarations?.[i])); return concatenate(args.slice(0, length - 1), syntheticArgs); } } @@ -26995,6 +27059,11 @@ namespace ts { return type; } + function getTupleElementLabel(d: ParameterDeclaration | NamedTupleMember) { + Debug.assert(isIdentifier(d.name)); // Parameter declarations could be binding patterns, but we only allow identifier names + return d.name.escapedText; + } + function getParameterNameAtPosition(signature: Signature, pos: number) { const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); if (pos < paramCount) { @@ -27003,13 +27072,33 @@ namespace ts { const restParameter = signature.parameters[paramCount] || unknownSymbol; const restType = getTypeOfSymbol(restParameter); if (isTupleType(restType)) { - const associatedNames = ((restType).target).associatedNames; + const associatedNames = ((restType).target).labeledElementDeclarations; const index = pos - paramCount; - return associatedNames && associatedNames[index] || restParameter.escapedName + "_" + index as __String; + return associatedNames && getTupleElementLabel(associatedNames[index]) || restParameter.escapedName + "_" + index as __String; } return restParameter.escapedName; } + function isValidDeclarationForTupleLabel(d: Declaration): d is NamedTupleMember | (ParameterDeclaration & { name: Identifier }) { + return d.kind === SyntaxKind.NamedTupleMember || (isParameter(d) && d.name && isIdentifier(d.name)); + } + + function getNameableDeclarationAtPosition(signature: Signature, pos: number) { + const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + const decl = signature.parameters[pos].valueDeclaration; + return decl && isValidDeclarationForTupleLabel(decl) ? decl : undefined; + } + const restParameter = signature.parameters[paramCount] || unknownSymbol; + const restType = getTypeOfSymbol(restParameter); + if (isTupleType(restType)) { + const associatedNames = ((restType).target).labeledElementDeclarations; + const index = pos - paramCount; + return associatedNames && associatedNames[index]; + } + return restParameter.valueDeclaration && isValidDeclarationForTupleLabel(restParameter.valueDeclaration) ? restParameter.valueDeclaration : undefined; + } + function getTypeAtPosition(signature: Signature, pos: number): Type { return tryGetTypeAtPosition(signature, pos) || anyType; } @@ -27040,14 +27129,26 @@ namespace ts { return restType; } const types = []; - const names = []; + let names: (NamedTupleMember | ParameterDeclaration)[] | undefined = []; for (let i = pos; i < nonRestCount; i++) { types.push(getTypeAtPosition(source, i)); - names.push(getParameterNameAtPosition(source, i)); + const name = getNameableDeclarationAtPosition(source, i); + if (name && names) { + names.push(name); + } + else { + names = undefined; + } } if (restType) { types.push(getIndexedAccessType(restType, numberType)); - names.push(getParameterNameAtPosition(source, nonRestCount)); + const name = getNameableDeclarationAtPosition(source, nonRestCount); + if (name && names) { + names.push(name); + } + else { + names = undefined; + } } const minArgumentCount = getMinArgumentCount(source); const minLength = minArgumentCount < pos ? 0 : minArgumentCount - pos; @@ -30123,11 +30224,19 @@ namespace ts { } function checkTupleType(node: TupleTypeNode) { - const elementTypes = node.elementTypes; + const elementTypes = node.elements; let seenOptionalElement = false; + let seenNamedElement = false; for (let i = 0; i < elementTypes.length; i++) { const e = elementTypes[i]; - if (e.kind === SyntaxKind.RestType) { + if (e.kind === SyntaxKind.NamedTupleMember) { + seenNamedElement = true; + } + else if (seenNamedElement) { + grammarErrorOnNode(e, Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names); + break; + } + if (isTupleRestElement(e)) { if (i !== elementTypes.length - 1) { grammarErrorOnNode(e, Diagnostics.A_rest_element_must_be_last_in_a_tuple_type); break; @@ -30136,7 +30245,7 @@ namespace ts { error(e, Diagnostics.A_rest_element_type_must_be_an_array_type); } } - else if (e.kind === SyntaxKind.OptionalType) { + else if (isTupleOptionalElement(e)) { seenOptionalElement = true; } else if (seenOptionalElement) { @@ -30144,7 +30253,7 @@ namespace ts { break; } } - forEach(node.elementTypes, checkSourceElement); + forEach(node.elements, checkSourceElement); } function checkUnionOrIntersectionType(node: UnionOrIntersectionTypeNode) { @@ -30230,6 +30339,20 @@ namespace ts { getTypeFromTypeNode(node); } + function checkNamedTupleMember(node: NamedTupleMember) { + if (node.dotDotDotToken && node.questionToken) { + grammarErrorOnNode(node, Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest); + } + if (node.type.kind === SyntaxKind.OptionalType) { + grammarErrorOnNode(node.type, Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type); + } + if (node.type.kind === SyntaxKind.RestType) { + grammarErrorOnNode(node.type, Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type); + } + checkSourceElement(node.type); + getTypeFromTypeNode(node); + } + function isPrivateWithinAmbient(node: Node): boolean { return (hasEffectiveModifier(node, ModifierFlags.Private) || isPrivateIdentifierPropertyDeclaration(node)) && !!(node.flags & NodeFlags.Ambient); } @@ -31009,6 +31132,7 @@ namespace ts { return getEntityNameForDecoratorMetadataFromTypeList([(node).trueType, (node).falseType]); case SyntaxKind.ParenthesizedType: + case SyntaxKind.NamedTupleMember: return getEntityNameForDecoratorMetadata((node).type); case SyntaxKind.TypeReference: @@ -31020,8 +31144,8 @@ namespace ts { function getEntityNameForDecoratorMetadataFromTypeList(types: readonly TypeNode[]): EntityName | undefined { let commonEntityName: EntityName | undefined; for (let typeNode of types) { - while (typeNode.kind === SyntaxKind.ParenthesizedType) { - typeNode = (typeNode as ParenthesizedTypeNode).type; // Skip parens if need be + while (typeNode.kind === SyntaxKind.ParenthesizedType || typeNode.kind === SyntaxKind.NamedTupleMember) { + typeNode = (typeNode as ParenthesizedTypeNode | NamedTupleMember).type; // Skip parens if need be } if (typeNode.kind === SyntaxKind.NeverKeyword) { continue; // Always elide `never` from the union/intersection if possible @@ -34774,6 +34898,8 @@ namespace ts { return checkInferType(node); case SyntaxKind.ImportType: return checkImportType(node); + case SyntaxKind.NamedTupleMember: + return checkNamedTupleMember(node); case SyntaxKind.JSDocAugmentsTag: return checkJSDocAugmentsTag(node as JSDocAugmentsTag); case SyntaxKind.JSDocImplementsTag: diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 2dfabe540adf7..df3192652aca9 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -3517,6 +3517,22 @@ "category": "Error", "code": 5083 }, + "Tuple members must all have names or all not have names.": { + "category": "Error", + "code": 5084 + }, + "A tuple member cannot be both optional and rest.": { + "category": "Error", + "code": 5085 + }, + "A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type.": { + "category": "Error", + "code": 5086 + }, + "A labeled tuple element is declared as rest with a `...` before the name, rather than before the type.": { + "category": "Error", + "code": 5087 + }, "Generates a sourcemap for each corresponding '.d.ts' file.": { "category": "Message", @@ -5677,6 +5693,14 @@ "category": "Message", "code": 95116 }, + "Move labeled tuple element modifiers to labels": { + "category": "Message", + "code": 95117 + }, + "Convert overload list to single signature": { + "category": "Message", + "code": 95118 + }, "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": { "category": "Error", diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index dc4b9ad5f2f5e..b2325d2e3e6f0 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1370,6 +1370,8 @@ namespace ts { case SyntaxKind.RestType: case SyntaxKind.JSDocVariadicType: return emitRestOrJSDocVariadicType(node as RestTypeNode | JSDocVariadicType); + case SyntaxKind.NamedTupleMember: + return emitNamedTupleMember(node as NamedTupleMember); // Binding patterns case SyntaxKind.ObjectBindingPattern: @@ -2099,9 +2101,19 @@ namespace ts { } function emitTupleType(node: TupleTypeNode) { - writePunctuation("["); - emitList(node, node.elementTypes, ListFormat.TupleTypeElements); - writePunctuation("]"); + emitTokenWithComment(SyntaxKind.OpenBracketToken, node.pos, writePunctuation, node); + const flags = getEmitFlags(node) & EmitFlags.SingleLine ? ListFormat.SingleLineTupleTypeElements : ListFormat.MultiLineTupleTypeElements; + emitList(node, node.elements, flags | ListFormat.NoSpaceIfEmpty); + emitTokenWithComment(SyntaxKind.CloseBracketToken, node.elements.end, writePunctuation, node); + } + + function emitNamedTupleMember(node: NamedTupleMember) { + emit(node.dotDotDotToken); + emit(node.name); + emit(node.questionToken); + emitTokenWithComment(SyntaxKind.ColonToken, node.name.end, writePunctuation, node); + writeSpace(); + emit(node.type); } function emitOptionalType(node: OptionalTypeNode) { @@ -4968,7 +4980,7 @@ namespace ts { } function emitLeadingSynthesizedComment(comment: SynthesizedComment) { - if (comment.kind === SyntaxKind.SingleLineCommentTrivia) { + if (comment.hasLeadingNewline || comment.kind === SyntaxKind.SingleLineCommentTrivia) { writer.writeLine(); } writeSynthesizedComment(comment); diff --git a/src/compiler/factoryPublic.ts b/src/compiler/factoryPublic.ts index ac1dcbb0435a6..030b527b30bd1 100644 --- a/src/compiler/factoryPublic.ts +++ b/src/compiler/factoryPublic.ts @@ -810,15 +810,15 @@ namespace ts { : node; } - export function createTupleTypeNode(elementTypes: readonly TypeNode[]) { + export function createTupleTypeNode(elements: readonly (TypeNode | NamedTupleMember)[]) { const node = createSynthesizedNode(SyntaxKind.TupleType) as TupleTypeNode; - node.elementTypes = createNodeArray(elementTypes); + node.elements = createNodeArray(elements); return node; } - export function updateTupleTypeNode(node: TupleTypeNode, elementTypes: readonly TypeNode[]) { - return node.elementTypes !== elementTypes - ? updateNode(createTupleTypeNode(elementTypes), node) + export function updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]) { + return node.elements !== elements + ? updateNode(createTupleTypeNode(elements), node) : node; } @@ -934,6 +934,24 @@ namespace ts { : node; } + export function createNamedTupleMember(dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode) { + const node = createSynthesizedNode(SyntaxKind.NamedTupleMember); + node.dotDotDotToken = dotDotDotToken; + node.name = name; + node.questionToken = questionToken; + node.type = type; + return node; + } + + export function updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode) { + return node.dotDotDotToken !== dotDotDotToken + || node.name !== name + || node.questionToken !== questionToken + || node.type !== type + ? updateNode(createNamedTupleMember(dotDotDotToken, name, questionToken, type), node) + : node; + } + export function createThisTypeNode() { return createSynthesizedNode(SyntaxKind.ThisType); } @@ -2616,6 +2634,21 @@ namespace ts { return node; } + + /* @internal */ + export function createJSDocVariadicType(type: TypeNode): JSDocVariadicType { + const node = createSynthesizedNode(SyntaxKind.JSDocVariadicType) as JSDocVariadicType; + node.type = type; + return node; + } + + /* @internal */ + export function updateJSDocVariadicType(node: JSDocVariadicType, type: TypeNode): JSDocVariadicType { + return node.type !== type + ? updateNode(createJSDocVariadicType(type), node) + : node; + } + // JSX export function createJsxElement(openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement) { diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index fdc1e8246ac0d..9754cdf64d362 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -179,7 +179,7 @@ namespace ts { case SyntaxKind.ArrayType: return visitNode(cbNode, (node).elementType); case SyntaxKind.TupleType: - return visitNodes(cbNode, cbNodes, (node).elementTypes); + return visitNodes(cbNode, cbNodes, (node).elements); case SyntaxKind.UnionType: case SyntaxKind.IntersectionType: return visitNodes(cbNode, cbNodes, (node).types); @@ -207,6 +207,11 @@ namespace ts { visitNode(cbNode, (node).type); case SyntaxKind.LiteralType: return visitNode(cbNode, (node).literal); + case SyntaxKind.NamedTupleMember: + return visitNode(cbNode, (node).dotDotDotToken) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).questionToken) || + visitNode(cbNode, (node).type); case SyntaxKind.ObjectBindingPattern: case SyntaxKind.ArrayBindingPattern: return visitNodes(cbNode, cbNodes, (node).elements); @@ -3056,9 +3061,33 @@ namespace ts { return type; } + function isNextTokenColonOrQuestionColon() { + return nextToken() === SyntaxKind.ColonToken || (token() === SyntaxKind.QuestionToken && nextToken() === SyntaxKind.ColonToken); + } + + function isTupleElementName() { + if (token() === SyntaxKind.DotDotDotToken) { + return tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon(); + } + return tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon(); + } + + function parseTupleElementNameOrTupleElementType() { + if (lookAhead(isTupleElementName)) { + const node = createNode(SyntaxKind.NamedTupleMember); + node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); + node.name = parseIdentifierName(); + node.questionToken = parseOptionalToken(SyntaxKind.QuestionToken); + parseExpected(SyntaxKind.ColonToken); + node.type = parseTupleElementType(); + return addJSDocComment(finishNode(node)); + } + return parseTupleElementType(); + } + function parseTupleType(): TupleTypeNode { const node = createNode(SyntaxKind.TupleType); - node.elementTypes = parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken); + node.elements = parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementNameOrTupleElementType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken); return finishNode(node); } diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index 1e9aa130f682b..00d01ec950809 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -1018,6 +1018,10 @@ namespace ts { } } + if (isTupleTypeNode(input) && (getLineAndCharacterOfPosition(currentSourceFile, input.pos).line === getLineAndCharacterOfPosition(currentSourceFile, input.end).line)) { + setEmitFlags(input, EmitFlags.SingleLine); + } + return cleanup(visitEachChild(input, visitDeclarationSubtree, context)); function cleanup(returnValue: T | undefined): T | undefined { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index aef4364a6b5c8..0c45dca9529fc 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -328,6 +328,7 @@ namespace ts { IndexedAccessType, MappedType, LiteralType, + NamedTupleMember, ImportType, // Binding patterns ObjectBindingPattern, @@ -700,6 +701,7 @@ namespace ts { | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration + | NamedTupleMember | EndOfFileToken; export type HasType = @@ -1274,7 +1276,15 @@ namespace ts { export interface TupleTypeNode extends TypeNode { kind: SyntaxKind.TupleType; - elementTypes: NodeArray; + elements: NodeArray; + } + + export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration { + kind: SyntaxKind.NamedTupleMember; + dotDotDotToken?: Token; + name: Identifier; + questionToken?: Token; + type: TypeNode; } export interface OptionalTypeNode extends TypeNode { @@ -1478,6 +1488,7 @@ namespace ts { kind: SyntaxKind.SyntheticExpression; isSpread: boolean; type: Type; + tupleNameSource?: ParameterDeclaration | NamedTupleMember; } // see: https://tc39.github.io/ecma262/#prod-ExponentiationExpression @@ -2590,6 +2601,7 @@ namespace ts { text: string; pos: -1; end: -1; + hasLeadingNewline?: boolean; } // represents a top level: { type } expression in a JSDoc comment. @@ -3495,7 +3507,7 @@ namespace ts { */ getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined; /* @internal */ getResolvedSignatureForSignatureHelp(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined; - /* @internal */ getExpandedParameters(sig: Signature): readonly Symbol[]; + /* @internal */ getExpandedParameters(sig: Signature): readonly (readonly Symbol[])[]; /* @internal */ hasEffectiveRestParameter(sig: Signature): boolean; getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined; isImplementationOfOverload(node: SignatureDeclaration): boolean | undefined; @@ -4148,6 +4160,7 @@ namespace ts { cjsExportMerged?: Symbol; // Version of the symbol with all non export= exports merged with the export= target typeOnlyDeclaration?: TypeOnlyCompatibleAliasDeclaration | false; // First resolved alias declaration that makes the symbol only usable in type constructs isConstructorDeclaredProperty?: boolean; // Property declared through 'this.x = ...' assignment in constructor + tupleLabelDeclaration?: NamedTupleMember | ParameterDeclaration; // Declaration associated with the tuple's label } /* @internal */ @@ -4618,7 +4631,7 @@ namespace ts { minLength: number; hasRestElement: boolean; readonly: boolean; - associatedNames?: __String[]; + labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]; } export interface TupleTypeReference extends TypeReference { @@ -6559,7 +6572,8 @@ namespace ts { SingleLineTypeLiteralMembers = SingleLine | SpaceBetweenBraces | SpaceBetweenSiblings, MultiLineTypeLiteralMembers = MultiLine | Indented | OptionalIfEmpty, - TupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine, + SingleLineTupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine, + MultiLineTupleTypeElements = CommaDelimited | Indented | SpaceBetweenSiblings | MultiLine, UnionTypeConstituents = BarDelimited | SpaceBetweenSiblings | SingleLine, IntersectionTypeConstituents = AmpersandDelimited | SpaceBetweenSiblings | SingleLine, ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings | NoSpaceIfEmpty, diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts index b21af6186db2f..544be6d6b4dd3 100644 --- a/src/compiler/visitorPublic.ts +++ b/src/compiler/visitorPublic.ts @@ -480,7 +480,7 @@ namespace ts { case SyntaxKind.TupleType: return updateTupleTypeNode((node), - nodesVisitor((node).elementTypes, visitor, isTypeNode)); + nodesVisitor((node).elements, visitor, isTypeNode)); case SyntaxKind.OptionalType: return updateOptionalTypeNode((node), @@ -517,6 +517,14 @@ namespace ts { (node).isTypeOf ); + case SyntaxKind.NamedTupleMember: + return updateNamedTupleMember(node, + visitNode((node).dotDotDotToken, visitor, isToken), + visitNode((node).name, visitor, isIdentifier), + visitNode((node).questionToken, visitor, isToken), + visitNode((node).type, visitor, isTypeNode), + ); + case SyntaxKind.ParenthesizedType: return updateParenthesizedType(node, visitNode((node).type, visitor, isTypeNode)); diff --git a/src/services/codefixes/fixIncorrectNamedTupleSyntax.ts b/src/services/codefixes/fixIncorrectNamedTupleSyntax.ts new file mode 100644 index 0000000000000..f1c3d35160625 --- /dev/null +++ b/src/services/codefixes/fixIncorrectNamedTupleSyntax.ts @@ -0,0 +1,52 @@ +/* @internal */ +namespace ts.codefix { + const fixId = "fixIncorrectNamedTupleSyntax"; + const errorCodes = [ + Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code, + Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code + ]; + + registerCodeFix({ + errorCodes, + getCodeActions: context => { + const { sourceFile, span } = context; + const namedTupleMember = getNamedTupleMember(sourceFile, span.start); + const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, namedTupleMember)); + return [createCodeFixAction(fixId, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)]; + }, + fixIds: [fixId] + }); + + function getNamedTupleMember(sourceFile: SourceFile, pos: number) { + const token = getTokenAtPosition(sourceFile, pos); + return findAncestor(token, t => t.kind === SyntaxKind.NamedTupleMember) as NamedTupleMember | undefined; + } + function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, namedTupleMember?: NamedTupleMember) { + if (!namedTupleMember) { + return; + } + let unwrappedType = namedTupleMember.type; + let sawOptional = false; + let sawRest = false; + while (unwrappedType.kind === SyntaxKind.OptionalType || unwrappedType.kind === SyntaxKind.RestType || unwrappedType.kind === SyntaxKind.ParenthesizedType) { + if (unwrappedType.kind === SyntaxKind.OptionalType) { + sawOptional = true; + } + else if (unwrappedType.kind === SyntaxKind.RestType) { + sawRest = true; + } + unwrappedType = (unwrappedType as OptionalTypeNode | RestTypeNode | ParenthesizedTypeNode).type; + } + const updated = updateNamedTupleMember( + namedTupleMember, + namedTupleMember.dotDotDotToken || (sawRest ? createToken(SyntaxKind.DotDotDotToken) : undefined), + namedTupleMember.name, + namedTupleMember.questionToken || (sawOptional ? createToken(SyntaxKind.QuestionToken) : undefined), + unwrappedType + ); + if (updated === namedTupleMember) { + return; + } + changes.replaceNode(sourceFile, namedTupleMember, updated); + } +} diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 5539a8e30cb2d..23011643811f3 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -574,7 +574,7 @@ namespace ts.formatting { return childKind !== SyntaxKind.JsxClosingFragment; case SyntaxKind.IntersectionType: case SyntaxKind.UnionType: - if (childKind === SyntaxKind.TypeLiteral) { + if (childKind === SyntaxKind.TypeLiteral || childKind === SyntaxKind.TupleType) { return false; } // falls through diff --git a/src/services/refactors/convertOverloadListToSingleSignature.ts b/src/services/refactors/convertOverloadListToSingleSignature.ts new file mode 100644 index 0000000000000..3c747fb373678 --- /dev/null +++ b/src/services/refactors/convertOverloadListToSingleSignature.ts @@ -0,0 +1,219 @@ +/* @internal */ +namespace ts.refactor.addOrRemoveBracesToArrowFunction { + const refactorName = "Convert overload list to single signature"; + const refactorDescription = Diagnostics.Convert_overload_list_to_single_signature.message; + registerRefactor(refactorName, { getEditsForAction, getAvailableActions }); + + + function getAvailableActions(context: RefactorContext): readonly ApplicableRefactorInfo[] { + const { file, startPosition, program } = context; + const info = getConvertableOverloadListAtPosition(file, startPosition, program); + if (!info) return emptyArray; + + return [{ + name: refactorName, + description: refactorDescription, + actions: [{ + name: refactorName, + description: refactorDescription + }] + }]; + } + + function getEditsForAction(context: RefactorContext): RefactorEditInfo | undefined { + const { file, startPosition, program } = context; + const signatureDecls = getConvertableOverloadListAtPosition(file, startPosition, program); + if (!signatureDecls) return undefined; + + const checker = program.getTypeChecker(); + + const lastDeclaration = signatureDecls[signatureDecls.length - 1]; + let updated = lastDeclaration; + switch (lastDeclaration.kind) { + case SyntaxKind.MethodSignature: { + updated = updateMethodSignature( + lastDeclaration, + lastDeclaration.typeParameters, + getNewParametersForCombinedSignature(signatureDecls), + lastDeclaration.type, + lastDeclaration.name, + lastDeclaration.questionToken + ); + break; + } + case SyntaxKind.MethodDeclaration: { + updated = updateMethod( + lastDeclaration, + lastDeclaration.decorators, + lastDeclaration.modifiers, + lastDeclaration.asteriskToken, + lastDeclaration.name, + lastDeclaration.questionToken, + lastDeclaration.typeParameters, + getNewParametersForCombinedSignature(signatureDecls), + lastDeclaration.type, + lastDeclaration.body + ); + break; + } + case SyntaxKind.CallSignature: { + updated = updateCallSignature( + lastDeclaration, + lastDeclaration.typeParameters, + getNewParametersForCombinedSignature(signatureDecls), + lastDeclaration.type, + ); + break; + } + case SyntaxKind.Constructor: { + updated = updateConstructor( + lastDeclaration, + lastDeclaration.decorators, + lastDeclaration.modifiers, + getNewParametersForCombinedSignature(signatureDecls), + lastDeclaration.body + ); + break; + } + case SyntaxKind.ConstructSignature: { + updated = updateConstructSignature( + lastDeclaration, + lastDeclaration.typeParameters, + getNewParametersForCombinedSignature(signatureDecls), + lastDeclaration.type, + ); + break; + } + case SyntaxKind.FunctionDeclaration: { + updated = updateFunctionDeclaration( + lastDeclaration, + lastDeclaration.decorators, + lastDeclaration.modifiers, + lastDeclaration.asteriskToken, + lastDeclaration.name, + lastDeclaration.typeParameters, + getNewParametersForCombinedSignature(signatureDecls), + lastDeclaration.type, + lastDeclaration.body + ); + break; + } + default: return Debug.failBadSyntaxKind(lastDeclaration, "Unhandled signature kind in overload list conversion refactoring"); + } + + if (updated === lastDeclaration) { + return; // No edits to apply, do nothing + } + + const edits = textChanges.ChangeTracker.with(context, t => { + t.replaceNodeRange(file, signatureDecls[0], signatureDecls[signatureDecls.length - 1], updated); + }); + + return { renameFilename: undefined, renameLocation: undefined, edits }; + + function getNewParametersForCombinedSignature(signatureDeclarations: (MethodSignature | MethodDeclaration | CallSignatureDeclaration | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration)[]): NodeArray { + const lastSig = signatureDeclarations[signatureDeclarations.length - 1]; + if (isFunctionLikeDeclaration(lastSig) && lastSig.body) { + // Trim away implementation signature arguments (they should already be compatible with overloads, but are likely less precise to guarantee compatability with the overloads) + signatureDeclarations = signatureDeclarations.slice(0, signatureDeclarations.length - 1); + } + return createNodeArray([ + createParameter( + /*decorators*/ undefined, + /*modifiers*/ undefined, + createToken(SyntaxKind.DotDotDotToken), + "args", + /*questionToken*/ undefined, + createUnionTypeNode(map(signatureDeclarations, convertSignatureParametersToTuple)) + ) + ]); + } + + function convertSignatureParametersToTuple(decl: MethodSignature | MethodDeclaration | CallSignatureDeclaration | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration): TupleTypeNode { + const members = map(decl.parameters, convertParameterToNamedTupleMember); + return setEmitFlags(createTupleTypeNode(members), some(members, m => !!length(getSyntheticLeadingComments(m))) ? EmitFlags.None : EmitFlags.SingleLine); + } + + function convertParameterToNamedTupleMember(p: ParameterDeclaration): NamedTupleMember { + Debug.assert(isIdentifier(p.name)); // This is checked during refactoring applicability checking + const result = setTextRange(createNamedTupleMember( + p.dotDotDotToken, + p.name, + p.questionToken, + p.type || createKeywordTypeNode(SyntaxKind.AnyKeyword) + ), p); + const parameterDocComment = p.symbol && p.symbol.getDocumentationComment(checker); + if (parameterDocComment) { + const newComment = displayPartsToString(parameterDocComment); + if (newComment.length) { + setSyntheticLeadingComments(result, [{ + text: `* +${newComment.split("\n").map(c => ` * ${c}`).join("\n")} + `, + kind: SyntaxKind.MultiLineCommentTrivia, + pos: -1, + end: -1, + hasTrailingNewLine: true, + hasLeadingNewline: true, + }]); + } + } + return result; + } + + } + + function isConvertableSignatureDeclaration(d: Node): d is MethodSignature | MethodDeclaration | CallSignatureDeclaration | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration { + switch (d.kind) { + case SyntaxKind.MethodSignature: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.CallSignature: + case SyntaxKind.Constructor: + case SyntaxKind.ConstructSignature: + case SyntaxKind.FunctionDeclaration: + return true; + } + return false; + } + + function getConvertableOverloadListAtPosition(file: SourceFile, startPosition: number, program: Program) { + const node = getTokenAtPosition(file, startPosition); + const containingDecl = findAncestor(node, isConvertableSignatureDeclaration); + if (!containingDecl) { + return; + } + const checker = program.getTypeChecker(); + const signatureSymbol = containingDecl.symbol; + if (!signatureSymbol) { + return; + } + const decls = signatureSymbol.declarations; + if (length(decls) <= 1) { + return; + } + if (!every(decls, d => getSourceFileOfNode(d) === file)) { + return; + } + if (!isConvertableSignatureDeclaration(decls[0])) { + return; + } + const kindOne = decls[0].kind; + if (!every(decls, d => d.kind === kindOne)) { + return; + } + const signatureDecls = decls as (MethodSignature | MethodDeclaration | CallSignatureDeclaration | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration)[]; + if (some(signatureDecls, d => !!d.typeParameters || some(d.parameters, p => !!p.decorators || !!p.modifiers || !isIdentifier(p.name)))) { + return; + } + const signatures = mapDefined(signatureDecls, d => checker.getSignatureFromDeclaration(d)); + if (length(signatures) !== length(decls)) { + return; + } + const returnOne = checker.getReturnTypeOfSignature(signatures[0]); + if (!every(signatures, s => checker.getReturnTypeOfSignature(s) === returnOne)) { + return; + } + + return signatureDecls; + } +} diff --git a/src/services/refactors/extractType.ts b/src/services/refactors/extractType.ts index 813ee186f0faa..560fc5deb684a 100644 --- a/src/services/refactors/extractType.ts +++ b/src/services/refactors/extractType.ts @@ -145,6 +145,11 @@ namespace ts.refactor { } } } + + if (file && isTupleTypeNode(node) && (getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line)) { + setEmitFlags(node, EmitFlags.SingleLine); + } + return forEachChild(node, visitor); } } diff --git a/src/services/services.ts b/src/services/services.ts index 6668ee14f37dc..28cf22ec473d1 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -328,7 +328,14 @@ namespace ts { getDocumentationComment(checker: TypeChecker | undefined): SymbolDisplayPart[] { if (!this.documentationComment) { this.documentationComment = emptyArray; // Set temporarily to avoid an infinite loop finding inherited docs - this.documentationComment = getDocumentationComment(this.declarations, checker); + + if (!this.declarations && (this as Symbol as TransientSymbol).target && ((this as Symbol as TransientSymbol).target as TransientSymbol).tupleLabelDeclaration) { + const labelDecl = ((this as Symbol as TransientSymbol).target as TransientSymbol).tupleLabelDeclaration!; + this.documentationComment = getDocumentationComment([labelDecl], checker); + } + else { + this.documentationComment = getDocumentationComment(this.declarations, checker); + } } return this.documentationComment; } diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts index 0f168d65e7b1f..d2244e3f894ca 100644 --- a/src/services/signatureHelp.ts +++ b/src/services/signatureHelp.ts @@ -500,16 +500,37 @@ namespace ts.SignatureHelp { const enclosingDeclaration = getEnclosingDeclarationFromInvocation(invocation); const callTargetSymbol = invocation.kind === InvocationKind.Contextual ? invocation.symbol : typeChecker.getSymbolAtLocation(getExpressionFromInvocation(invocation)); const callTargetDisplayParts = callTargetSymbol ? symbolToDisplayParts(typeChecker, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : emptyArray; - const items = candidates.map(candidateSignature => getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, typeChecker, enclosingDeclaration, sourceFile)); + const items = map(candidates, candidateSignature => getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, typeChecker, enclosingDeclaration, sourceFile)); if (argumentIndex !== 0) { Debug.assertLessThan(argumentIndex, argumentCount); } - const selectedItemIndex = candidates.indexOf(resolvedSignature); + let selectedItemIndex = 0; + let itemsSeen = 0; + for (let i = 0; i < items.length; i++) { + const item = items[i]; + if (candidates[i] === resolvedSignature) { + selectedItemIndex = itemsSeen; + if (item.length > 1) { + // check to see if any items in the list better match than the first one, as the checker isn't filtering the nested lists + // (those come from tuple parameter expansion) + let count = 0; + for (const i of item) { + if (i.isVariadic || i.parameters.length >= argumentCount) { + selectedItemIndex = itemsSeen + count; + break; + } + count++; + } + } + } + itemsSeen += item.length; + } + Debug.assert(selectedItemIndex !== -1); // If candidates is non-empty it should always include bestSignature. We check for an empty candidates before calling this function. - return { items, applicableSpan, selectedItemIndex, argumentIndex, argumentCount }; + return { items: flatMapToMutable(items, identity), applicableSpan, selectedItemIndex, argumentIndex, argumentCount }; } function createTypeHelpItems( @@ -538,13 +559,15 @@ namespace ts.SignatureHelp { const separatorDisplayParts: SymbolDisplayPart[] = [punctuationPart(SyntaxKind.CommaToken), spacePart()]; - function getSignatureHelpItem(candidateSignature: Signature, callTargetDisplayParts: readonly SymbolDisplayPart[], isTypeParameterList: boolean, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItem { - const { isVariadic, parameters, prefix, suffix } = (isTypeParameterList ? itemInfoForTypeParameters : itemInfoForParameters)(candidateSignature, checker, enclosingDeclaration, sourceFile); - const prefixDisplayParts = [...callTargetDisplayParts, ...prefix]; - const suffixDisplayParts = [...suffix, ...returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker)]; - const documentation = candidateSignature.getDocumentationComment(checker); - const tags = candidateSignature.getJsDocTags(); - return { isVariadic, prefixDisplayParts, suffixDisplayParts, separatorDisplayParts, parameters, documentation, tags }; + function getSignatureHelpItem(candidateSignature: Signature, callTargetDisplayParts: readonly SymbolDisplayPart[], isTypeParameterList: boolean, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItem[] { + const infos = (isTypeParameterList ? itemInfoForTypeParameters : itemInfoForParameters)(candidateSignature, checker, enclosingDeclaration, sourceFile); + return map(infos, ({ isVariadic, parameters, prefix, suffix }) => { + const prefixDisplayParts = [...callTargetDisplayParts, ...prefix]; + const suffixDisplayParts = [...suffix, ...returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker)]; + const documentation = candidateSignature.getDocumentationComment(checker); + const tags = candidateSignature.getJsDocTags(); + return { isVariadic, prefixDisplayParts, suffixDisplayParts, separatorDisplayParts, parameters, documentation, tags }; + }); } function returnTypeToDisplayParts(candidateSignature: Signature, enclosingDeclaration: Node, checker: TypeChecker): readonly SymbolDisplayPart[] { @@ -563,19 +586,22 @@ namespace ts.SignatureHelp { interface SignatureHelpItemInfo { readonly isVariadic: boolean; readonly parameters: SignatureHelpParameter[]; readonly prefix: readonly SymbolDisplayPart[]; readonly suffix: readonly SymbolDisplayPart[]; } - function itemInfoForTypeParameters(candidateSignature: Signature, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItemInfo { + function itemInfoForTypeParameters(candidateSignature: Signature, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItemInfo[] { const typeParameters = (candidateSignature.target || candidateSignature).typeParameters; const printer = createPrinter({ removeComments: true }); const parameters = (typeParameters || emptyArray).map(t => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer)); - const parameterParts = mapToDisplayParts(writer => { - const thisParameter = candidateSignature.thisParameter ? [checker.symbolToParameterDeclaration(candidateSignature.thisParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags)!] : []; - const params = createNodeArray([...thisParameter, ...checker.getExpandedParameters(candidateSignature).map(param => checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags)!)]); - printer.writeList(ListFormat.CallExpressionArguments, params, sourceFile, writer); + const thisParameter = candidateSignature.thisParameter ? [checker.symbolToParameterDeclaration(candidateSignature.thisParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags)!] : []; + + return checker.getExpandedParameters(candidateSignature).map(paramList => { + const params = createNodeArray([...thisParameter, ...map(paramList, param => checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags)!)]); + const parameterParts = mapToDisplayParts(writer => { + printer.writeList(ListFormat.CallExpressionArguments, params, sourceFile, writer); + }); + return { isVariadic: false, parameters, prefix: [punctuationPart(SyntaxKind.LessThanToken)], suffix: [punctuationPart(SyntaxKind.GreaterThanToken), ...parameterParts] }; }); - return { isVariadic: false, parameters, prefix: [punctuationPart(SyntaxKind.LessThanToken)], suffix: [punctuationPart(SyntaxKind.GreaterThanToken), ...parameterParts] }; } - function itemInfoForParameters(candidateSignature: Signature, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItemInfo { + function itemInfoForParameters(candidateSignature: Signature, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItemInfo[] { const isVariadic = checker.hasEffectiveRestParameter(candidateSignature); const printer = createPrinter({ removeComments: true }); const typeParameterParts = mapToDisplayParts(writer => { @@ -584,8 +610,15 @@ namespace ts.SignatureHelp { printer.writeList(ListFormat.TypeParameters, args, sourceFile, writer); } }); - const parameters = checker.getExpandedParameters(candidateSignature).map(p => createSignatureHelpParameterForParameter(p, checker, enclosingDeclaration, sourceFile, printer)); - return { isVariadic, parameters, prefix: [...typeParameterParts, punctuationPart(SyntaxKind.OpenParenToken)], suffix: [punctuationPart(SyntaxKind.CloseParenToken)] }; + const lists = checker.getExpandedParameters(candidateSignature); + return lists.map(parameterList => { + return { + isVariadic: isVariadic && (lists.length === 1 || !!((parameterList[parameterList.length - 1] as TransientSymbol).checkFlags & CheckFlags.RestParameter)), + parameters: parameterList.map(p => createSignatureHelpParameterForParameter(p, checker, enclosingDeclaration, sourceFile, printer)), + prefix: [...typeParameterParts, punctuationPart(SyntaxKind.OpenParenToken)], + suffix: [punctuationPart(SyntaxKind.CloseParenToken)] + }; + }); } function createSignatureHelpParameterForParameter(parameter: Symbol, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile, printer: Printer): SignatureHelpParameter { diff --git a/src/services/symbolDisplay.ts b/src/services/symbolDisplay.ts index 138ed53c50d0b..11f201951315b 100644 --- a/src/services/symbolDisplay.ts +++ b/src/services/symbolDisplay.ts @@ -481,6 +481,14 @@ namespace ts.SymbolDisplay { else { addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration)); } + if ((symbol as TransientSymbol).target && ((symbol as TransientSymbol).target as TransientSymbol).tupleLabelDeclaration) { + const labelDecl = ((symbol as TransientSymbol).target as TransientSymbol).tupleLabelDeclaration!; + Debug.assertNode(labelDecl.name, isIdentifier); + displayParts.push(spacePart()); + displayParts.push(punctuationPart(SyntaxKind.OpenParenToken)); + displayParts.push(textPart(idText(labelDecl.name))); + displayParts.push(punctuationPart(SyntaxKind.CloseParenToken)); + } } else if (symbolFlags & SymbolFlags.Function || symbolFlags & SymbolFlags.Method || diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index bbe3956e173c1..f3e6e5ce4566b 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -64,6 +64,7 @@ "codefixes/fixClassIncorrectlyImplementsInterface.ts", "codefixes/importFixes.ts", "codefixes/fixImplicitThis.ts", + "codefixes/fixIncorrectNamedTupleSyntax.ts", "codefixes/fixSpelling.ts", "codefixes/returnValueCorrect.ts", "codefixes/fixAddMissingMember.ts", @@ -101,6 +102,7 @@ "codefixes/fixExpectedComma.ts", "refactors/convertExport.ts", "refactors/convertImport.ts", + "refactors/convertOverloadListToSingleSignature.ts", "refactors/extractSymbol.ts", "refactors/extractType.ts", "refactors/generateGetAccessorAndSetAccessor.ts", diff --git a/src/testRunner/unittests/printer.ts b/src/testRunner/unittests/printer.ts index d04bf65603c11..e96aba3674948 100644 --- a/src/testRunner/unittests/printer.ts +++ b/src/testRunner/unittests/printer.ts @@ -229,7 +229,7 @@ namespace ts { // https://github.com/Microsoft/TypeScript/issues/15651 printsCorrectly("functionTypes", {}, printer => printer.printNode( EmitHint.Unspecified, - createTupleTypeNode([ + setEmitFlags(createTupleTypeNode([ createFunctionTypeNode( /*typeArguments*/ undefined, [createParameter( @@ -293,7 +293,7 @@ namespace ts { )], createKeywordTypeNode(SyntaxKind.AnyKeyword) ), - ]), + ]), EmitFlags.SingleLine), createSourceFile("source.ts", "", ScriptTarget.ES2015) )); }); diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType0.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType0.json index 61631cabce44b..8bce108137668 100644 --- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType0.json +++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType0.json @@ -5,7 +5,7 @@ "flags": "JSDoc", "modifierFlagsCache": 0, "transformFlags": 0, - "elementTypes": { + "elements": { "length": 0, "pos": 2, "end": 2 diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType1.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType1.json index c8373fe5e875a..dc98f9164e73a 100644 --- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType1.json +++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType1.json @@ -5,7 +5,7 @@ "flags": "JSDoc", "modifierFlagsCache": 0, "transformFlags": 0, - "elementTypes": { + "elements": { "0": { "kind": "NumberKeyword", "pos": 2, diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType2.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType2.json index 78875855840e8..f6da41187797f 100644 --- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType2.json +++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType2.json @@ -5,7 +5,7 @@ "flags": "JSDoc", "modifierFlagsCache": 0, "transformFlags": 0, - "elementTypes": { + "elements": { "0": { "kind": "NumberKeyword", "pos": 2, diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType3.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType3.json index c1b537d2945af..08c3a7dbede68 100644 --- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType3.json +++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType3.json @@ -5,7 +5,7 @@ "flags": "JSDoc", "modifierFlagsCache": 0, "transformFlags": 0, - "elementTypes": { + "elements": { "0": { "kind": "NumberKeyword", "pos": 2, diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleTypeWithTrailingComma.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleTypeWithTrailingComma.json index b859519b8da34..da5978138999b 100644 --- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleTypeWithTrailingComma.json +++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleTypeWithTrailingComma.json @@ -5,7 +5,7 @@ "flags": "JSDoc", "modifierFlagsCache": 0, "transformFlags": 0, - "elementTypes": { + "elements": { "0": { "kind": "NumberKeyword", "pos": 2, diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 6ea68e933ab4b..e89d9461ff314 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -263,150 +263,151 @@ declare namespace ts { IndexedAccessType = 185, MappedType = 186, LiteralType = 187, - ImportType = 188, - ObjectBindingPattern = 189, - ArrayBindingPattern = 190, - BindingElement = 191, - ArrayLiteralExpression = 192, - ObjectLiteralExpression = 193, - PropertyAccessExpression = 194, - ElementAccessExpression = 195, - CallExpression = 196, - NewExpression = 197, - TaggedTemplateExpression = 198, - TypeAssertionExpression = 199, - ParenthesizedExpression = 200, - FunctionExpression = 201, - ArrowFunction = 202, - DeleteExpression = 203, - TypeOfExpression = 204, - VoidExpression = 205, - AwaitExpression = 206, - PrefixUnaryExpression = 207, - PostfixUnaryExpression = 208, - BinaryExpression = 209, - ConditionalExpression = 210, - TemplateExpression = 211, - YieldExpression = 212, - SpreadElement = 213, - ClassExpression = 214, - OmittedExpression = 215, - ExpressionWithTypeArguments = 216, - AsExpression = 217, - NonNullExpression = 218, - MetaProperty = 219, - SyntheticExpression = 220, - TemplateSpan = 221, - SemicolonClassElement = 222, - Block = 223, - EmptyStatement = 224, - VariableStatement = 225, - ExpressionStatement = 226, - IfStatement = 227, - DoStatement = 228, - WhileStatement = 229, - ForStatement = 230, - ForInStatement = 231, - ForOfStatement = 232, - ContinueStatement = 233, - BreakStatement = 234, - ReturnStatement = 235, - WithStatement = 236, - SwitchStatement = 237, - LabeledStatement = 238, - ThrowStatement = 239, - TryStatement = 240, - DebuggerStatement = 241, - VariableDeclaration = 242, - VariableDeclarationList = 243, - FunctionDeclaration = 244, - ClassDeclaration = 245, - InterfaceDeclaration = 246, - TypeAliasDeclaration = 247, - EnumDeclaration = 248, - ModuleDeclaration = 249, - ModuleBlock = 250, - CaseBlock = 251, - NamespaceExportDeclaration = 252, - ImportEqualsDeclaration = 253, - ImportDeclaration = 254, - ImportClause = 255, - NamespaceImport = 256, - NamedImports = 257, - ImportSpecifier = 258, - ExportAssignment = 259, - ExportDeclaration = 260, - NamedExports = 261, - NamespaceExport = 262, - ExportSpecifier = 263, - MissingDeclaration = 264, - ExternalModuleReference = 265, - JsxElement = 266, - JsxSelfClosingElement = 267, - JsxOpeningElement = 268, - JsxClosingElement = 269, - JsxFragment = 270, - JsxOpeningFragment = 271, - JsxClosingFragment = 272, - JsxAttribute = 273, - JsxAttributes = 274, - JsxSpreadAttribute = 275, - JsxExpression = 276, - CaseClause = 277, - DefaultClause = 278, - HeritageClause = 279, - CatchClause = 280, - PropertyAssignment = 281, - ShorthandPropertyAssignment = 282, - SpreadAssignment = 283, - EnumMember = 284, - UnparsedPrologue = 285, - UnparsedPrepend = 286, - UnparsedText = 287, - UnparsedInternalText = 288, - UnparsedSyntheticReference = 289, - SourceFile = 290, - Bundle = 291, - UnparsedSource = 292, - InputFiles = 293, - JSDocTypeExpression = 294, - JSDocAllType = 295, - JSDocUnknownType = 296, - JSDocNullableType = 297, - JSDocNonNullableType = 298, - JSDocOptionalType = 299, - JSDocFunctionType = 300, - JSDocVariadicType = 301, - JSDocNamepathType = 302, - JSDocComment = 303, - JSDocTypeLiteral = 304, - JSDocSignature = 305, - JSDocTag = 306, - JSDocAugmentsTag = 307, - JSDocImplementsTag = 308, - JSDocAuthorTag = 309, - JSDocClassTag = 310, - JSDocPublicTag = 311, - JSDocPrivateTag = 312, - JSDocProtectedTag = 313, - JSDocReadonlyTag = 314, - JSDocCallbackTag = 315, - JSDocEnumTag = 316, - JSDocParameterTag = 317, - JSDocReturnTag = 318, - JSDocThisTag = 319, - JSDocTypeTag = 320, - JSDocTemplateTag = 321, - JSDocTypedefTag = 322, - JSDocPropertyTag = 323, - SyntaxList = 324, - NotEmittedStatement = 325, - PartiallyEmittedExpression = 326, - CommaListExpression = 327, - MergeDeclarationMarker = 328, - EndOfDeclarationMarker = 329, - SyntheticReferenceExpression = 330, - Count = 331, + NamedTupleMember = 188, + ImportType = 189, + ObjectBindingPattern = 190, + ArrayBindingPattern = 191, + BindingElement = 192, + ArrayLiteralExpression = 193, + ObjectLiteralExpression = 194, + PropertyAccessExpression = 195, + ElementAccessExpression = 196, + CallExpression = 197, + NewExpression = 198, + TaggedTemplateExpression = 199, + TypeAssertionExpression = 200, + ParenthesizedExpression = 201, + FunctionExpression = 202, + ArrowFunction = 203, + DeleteExpression = 204, + TypeOfExpression = 205, + VoidExpression = 206, + AwaitExpression = 207, + PrefixUnaryExpression = 208, + PostfixUnaryExpression = 209, + BinaryExpression = 210, + ConditionalExpression = 211, + TemplateExpression = 212, + YieldExpression = 213, + SpreadElement = 214, + ClassExpression = 215, + OmittedExpression = 216, + ExpressionWithTypeArguments = 217, + AsExpression = 218, + NonNullExpression = 219, + MetaProperty = 220, + SyntheticExpression = 221, + TemplateSpan = 222, + SemicolonClassElement = 223, + Block = 224, + EmptyStatement = 225, + VariableStatement = 226, + ExpressionStatement = 227, + IfStatement = 228, + DoStatement = 229, + WhileStatement = 230, + ForStatement = 231, + ForInStatement = 232, + ForOfStatement = 233, + ContinueStatement = 234, + BreakStatement = 235, + ReturnStatement = 236, + WithStatement = 237, + SwitchStatement = 238, + LabeledStatement = 239, + ThrowStatement = 240, + TryStatement = 241, + DebuggerStatement = 242, + VariableDeclaration = 243, + VariableDeclarationList = 244, + FunctionDeclaration = 245, + ClassDeclaration = 246, + InterfaceDeclaration = 247, + TypeAliasDeclaration = 248, + EnumDeclaration = 249, + ModuleDeclaration = 250, + ModuleBlock = 251, + CaseBlock = 252, + NamespaceExportDeclaration = 253, + ImportEqualsDeclaration = 254, + ImportDeclaration = 255, + ImportClause = 256, + NamespaceImport = 257, + NamedImports = 258, + ImportSpecifier = 259, + ExportAssignment = 260, + ExportDeclaration = 261, + NamedExports = 262, + NamespaceExport = 263, + ExportSpecifier = 264, + MissingDeclaration = 265, + ExternalModuleReference = 266, + JsxElement = 267, + JsxSelfClosingElement = 268, + JsxOpeningElement = 269, + JsxClosingElement = 270, + JsxFragment = 271, + JsxOpeningFragment = 272, + JsxClosingFragment = 273, + JsxAttribute = 274, + JsxAttributes = 275, + JsxSpreadAttribute = 276, + JsxExpression = 277, + CaseClause = 278, + DefaultClause = 279, + HeritageClause = 280, + CatchClause = 281, + PropertyAssignment = 282, + ShorthandPropertyAssignment = 283, + SpreadAssignment = 284, + EnumMember = 285, + UnparsedPrologue = 286, + UnparsedPrepend = 287, + UnparsedText = 288, + UnparsedInternalText = 289, + UnparsedSyntheticReference = 290, + SourceFile = 291, + Bundle = 292, + UnparsedSource = 293, + InputFiles = 294, + JSDocTypeExpression = 295, + JSDocAllType = 296, + JSDocUnknownType = 297, + JSDocNullableType = 298, + JSDocNonNullableType = 299, + JSDocOptionalType = 300, + JSDocFunctionType = 301, + JSDocVariadicType = 302, + JSDocNamepathType = 303, + JSDocComment = 304, + JSDocTypeLiteral = 305, + JSDocSignature = 306, + JSDocTag = 307, + JSDocAugmentsTag = 308, + JSDocImplementsTag = 309, + JSDocAuthorTag = 310, + JSDocClassTag = 311, + JSDocPublicTag = 312, + JSDocPrivateTag = 313, + JSDocProtectedTag = 314, + JSDocReadonlyTag = 315, + JSDocCallbackTag = 316, + JSDocEnumTag = 317, + JSDocParameterTag = 318, + JSDocReturnTag = 319, + JSDocThisTag = 320, + JSDocTypeTag = 321, + JSDocTemplateTag = 322, + JSDocTypedefTag = 323, + JSDocPropertyTag = 324, + SyntaxList = 325, + NotEmittedStatement = 326, + PartiallyEmittedExpression = 327, + CommaListExpression = 328, + MergeDeclarationMarker = 329, + EndOfDeclarationMarker = 330, + SyntheticReferenceExpression = 331, + Count = 332, FirstAssignment = 62, LastAssignment = 74, FirstCompoundAssignment = 63, @@ -418,7 +419,7 @@ declare namespace ts { FirstFutureReservedWord = 113, LastFutureReservedWord = 121, FirstTypeNode = 168, - LastTypeNode = 188, + LastTypeNode = 189, FirstPunctuation = 18, LastPunctuation = 74, FirstToken = 0, @@ -431,13 +432,13 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 74, - FirstStatement = 225, - LastStatement = 241, + FirstStatement = 226, + LastStatement = 242, FirstNode = 153, - FirstJSDocNode = 294, - LastJSDocNode = 323, - FirstJSDocTagNode = 306, - LastJSDocTagNode = 323, + FirstJSDocNode = 295, + LastJSDocNode = 324, + FirstJSDocTagNode = 307, + LastJSDocTagNode = 324, } export enum NodeFlags { None = 0, @@ -508,7 +509,7 @@ declare namespace ts { } export interface JSDocContainer { } - export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | LabeledStatement | ExpressionStatement | VariableStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | EndOfFileToken; + export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | LabeledStatement | ExpressionStatement | VariableStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | NamedTupleMember | EndOfFileToken; export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType; export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement; export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute; @@ -809,7 +810,14 @@ declare namespace ts { } export interface TupleTypeNode extends TypeNode { kind: SyntaxKind.TupleType; - elementTypes: NodeArray; + elements: NodeArray; + } + export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration { + kind: SyntaxKind.NamedTupleMember; + dotDotDotToken?: Token; + name: Identifier; + questionToken?: Token; + type: TypeNode; } export interface OptionalTypeNode extends TypeNode { kind: SyntaxKind.OptionalType; @@ -947,6 +955,7 @@ declare namespace ts { kind: SyntaxKind.SyntheticExpression; isSpread: boolean; type: Type; + tupleNameSource?: ParameterDeclaration | NamedTupleMember; } export type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken; export type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken; @@ -1578,6 +1587,7 @@ declare namespace ts { text: string; pos: -1; end: -1; + hasLeadingNewline?: boolean; } export interface JSDocTypeExpression extends TypeNode { kind: SyntaxKind.JSDocTypeExpression; @@ -2466,7 +2476,7 @@ declare namespace ts { minLength: number; hasRestElement: boolean; readonly: boolean; - associatedNames?: __String[]; + labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]; } export interface TupleTypeReference extends TypeReference { target: TupleType; @@ -3223,7 +3233,8 @@ declare namespace ts { HeritageClauses = 512, SingleLineTypeLiteralMembers = 768, MultiLineTypeLiteralMembers = 32897, - TupleTypeElements = 528, + SingleLineTupleTypeElements = 528, + MultiLineTupleTypeElements = 657, UnionTypeConstituents = 516, IntersectionTypeConstituents = 520, ObjectBindingPatternElements = 525136, @@ -4043,8 +4054,8 @@ declare namespace ts { function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray): TypeLiteralNode; function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode; function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode; - function createTupleTypeNode(elementTypes: readonly TypeNode[]): TupleTypeNode; - function updateTupleTypeNode(node: TupleTypeNode, elementTypes: readonly TypeNode[]): TupleTypeNode; + function createTupleTypeNode(elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode; + function updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode; function createOptionalTypeNode(type: TypeNode): OptionalTypeNode; function updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode; function createRestTypeNode(type: TypeNode): RestTypeNode; @@ -4062,6 +4073,8 @@ declare namespace ts { function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode; function createParenthesizedType(type: TypeNode): ParenthesizedTypeNode; function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode; + function createNamedTupleMember(dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode): NamedTupleMember; + function updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode): NamedTupleMember; function createThisTypeNode(): ThisTypeNode; function createTypeOperatorNode(type: TypeNode): TypeOperatorNode; function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index d2c5d5ce805df..2213fd4be6a66 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -263,150 +263,151 @@ declare namespace ts { IndexedAccessType = 185, MappedType = 186, LiteralType = 187, - ImportType = 188, - ObjectBindingPattern = 189, - ArrayBindingPattern = 190, - BindingElement = 191, - ArrayLiteralExpression = 192, - ObjectLiteralExpression = 193, - PropertyAccessExpression = 194, - ElementAccessExpression = 195, - CallExpression = 196, - NewExpression = 197, - TaggedTemplateExpression = 198, - TypeAssertionExpression = 199, - ParenthesizedExpression = 200, - FunctionExpression = 201, - ArrowFunction = 202, - DeleteExpression = 203, - TypeOfExpression = 204, - VoidExpression = 205, - AwaitExpression = 206, - PrefixUnaryExpression = 207, - PostfixUnaryExpression = 208, - BinaryExpression = 209, - ConditionalExpression = 210, - TemplateExpression = 211, - YieldExpression = 212, - SpreadElement = 213, - ClassExpression = 214, - OmittedExpression = 215, - ExpressionWithTypeArguments = 216, - AsExpression = 217, - NonNullExpression = 218, - MetaProperty = 219, - SyntheticExpression = 220, - TemplateSpan = 221, - SemicolonClassElement = 222, - Block = 223, - EmptyStatement = 224, - VariableStatement = 225, - ExpressionStatement = 226, - IfStatement = 227, - DoStatement = 228, - WhileStatement = 229, - ForStatement = 230, - ForInStatement = 231, - ForOfStatement = 232, - ContinueStatement = 233, - BreakStatement = 234, - ReturnStatement = 235, - WithStatement = 236, - SwitchStatement = 237, - LabeledStatement = 238, - ThrowStatement = 239, - TryStatement = 240, - DebuggerStatement = 241, - VariableDeclaration = 242, - VariableDeclarationList = 243, - FunctionDeclaration = 244, - ClassDeclaration = 245, - InterfaceDeclaration = 246, - TypeAliasDeclaration = 247, - EnumDeclaration = 248, - ModuleDeclaration = 249, - ModuleBlock = 250, - CaseBlock = 251, - NamespaceExportDeclaration = 252, - ImportEqualsDeclaration = 253, - ImportDeclaration = 254, - ImportClause = 255, - NamespaceImport = 256, - NamedImports = 257, - ImportSpecifier = 258, - ExportAssignment = 259, - ExportDeclaration = 260, - NamedExports = 261, - NamespaceExport = 262, - ExportSpecifier = 263, - MissingDeclaration = 264, - ExternalModuleReference = 265, - JsxElement = 266, - JsxSelfClosingElement = 267, - JsxOpeningElement = 268, - JsxClosingElement = 269, - JsxFragment = 270, - JsxOpeningFragment = 271, - JsxClosingFragment = 272, - JsxAttribute = 273, - JsxAttributes = 274, - JsxSpreadAttribute = 275, - JsxExpression = 276, - CaseClause = 277, - DefaultClause = 278, - HeritageClause = 279, - CatchClause = 280, - PropertyAssignment = 281, - ShorthandPropertyAssignment = 282, - SpreadAssignment = 283, - EnumMember = 284, - UnparsedPrologue = 285, - UnparsedPrepend = 286, - UnparsedText = 287, - UnparsedInternalText = 288, - UnparsedSyntheticReference = 289, - SourceFile = 290, - Bundle = 291, - UnparsedSource = 292, - InputFiles = 293, - JSDocTypeExpression = 294, - JSDocAllType = 295, - JSDocUnknownType = 296, - JSDocNullableType = 297, - JSDocNonNullableType = 298, - JSDocOptionalType = 299, - JSDocFunctionType = 300, - JSDocVariadicType = 301, - JSDocNamepathType = 302, - JSDocComment = 303, - JSDocTypeLiteral = 304, - JSDocSignature = 305, - JSDocTag = 306, - JSDocAugmentsTag = 307, - JSDocImplementsTag = 308, - JSDocAuthorTag = 309, - JSDocClassTag = 310, - JSDocPublicTag = 311, - JSDocPrivateTag = 312, - JSDocProtectedTag = 313, - JSDocReadonlyTag = 314, - JSDocCallbackTag = 315, - JSDocEnumTag = 316, - JSDocParameterTag = 317, - JSDocReturnTag = 318, - JSDocThisTag = 319, - JSDocTypeTag = 320, - JSDocTemplateTag = 321, - JSDocTypedefTag = 322, - JSDocPropertyTag = 323, - SyntaxList = 324, - NotEmittedStatement = 325, - PartiallyEmittedExpression = 326, - CommaListExpression = 327, - MergeDeclarationMarker = 328, - EndOfDeclarationMarker = 329, - SyntheticReferenceExpression = 330, - Count = 331, + NamedTupleMember = 188, + ImportType = 189, + ObjectBindingPattern = 190, + ArrayBindingPattern = 191, + BindingElement = 192, + ArrayLiteralExpression = 193, + ObjectLiteralExpression = 194, + PropertyAccessExpression = 195, + ElementAccessExpression = 196, + CallExpression = 197, + NewExpression = 198, + TaggedTemplateExpression = 199, + TypeAssertionExpression = 200, + ParenthesizedExpression = 201, + FunctionExpression = 202, + ArrowFunction = 203, + DeleteExpression = 204, + TypeOfExpression = 205, + VoidExpression = 206, + AwaitExpression = 207, + PrefixUnaryExpression = 208, + PostfixUnaryExpression = 209, + BinaryExpression = 210, + ConditionalExpression = 211, + TemplateExpression = 212, + YieldExpression = 213, + SpreadElement = 214, + ClassExpression = 215, + OmittedExpression = 216, + ExpressionWithTypeArguments = 217, + AsExpression = 218, + NonNullExpression = 219, + MetaProperty = 220, + SyntheticExpression = 221, + TemplateSpan = 222, + SemicolonClassElement = 223, + Block = 224, + EmptyStatement = 225, + VariableStatement = 226, + ExpressionStatement = 227, + IfStatement = 228, + DoStatement = 229, + WhileStatement = 230, + ForStatement = 231, + ForInStatement = 232, + ForOfStatement = 233, + ContinueStatement = 234, + BreakStatement = 235, + ReturnStatement = 236, + WithStatement = 237, + SwitchStatement = 238, + LabeledStatement = 239, + ThrowStatement = 240, + TryStatement = 241, + DebuggerStatement = 242, + VariableDeclaration = 243, + VariableDeclarationList = 244, + FunctionDeclaration = 245, + ClassDeclaration = 246, + InterfaceDeclaration = 247, + TypeAliasDeclaration = 248, + EnumDeclaration = 249, + ModuleDeclaration = 250, + ModuleBlock = 251, + CaseBlock = 252, + NamespaceExportDeclaration = 253, + ImportEqualsDeclaration = 254, + ImportDeclaration = 255, + ImportClause = 256, + NamespaceImport = 257, + NamedImports = 258, + ImportSpecifier = 259, + ExportAssignment = 260, + ExportDeclaration = 261, + NamedExports = 262, + NamespaceExport = 263, + ExportSpecifier = 264, + MissingDeclaration = 265, + ExternalModuleReference = 266, + JsxElement = 267, + JsxSelfClosingElement = 268, + JsxOpeningElement = 269, + JsxClosingElement = 270, + JsxFragment = 271, + JsxOpeningFragment = 272, + JsxClosingFragment = 273, + JsxAttribute = 274, + JsxAttributes = 275, + JsxSpreadAttribute = 276, + JsxExpression = 277, + CaseClause = 278, + DefaultClause = 279, + HeritageClause = 280, + CatchClause = 281, + PropertyAssignment = 282, + ShorthandPropertyAssignment = 283, + SpreadAssignment = 284, + EnumMember = 285, + UnparsedPrologue = 286, + UnparsedPrepend = 287, + UnparsedText = 288, + UnparsedInternalText = 289, + UnparsedSyntheticReference = 290, + SourceFile = 291, + Bundle = 292, + UnparsedSource = 293, + InputFiles = 294, + JSDocTypeExpression = 295, + JSDocAllType = 296, + JSDocUnknownType = 297, + JSDocNullableType = 298, + JSDocNonNullableType = 299, + JSDocOptionalType = 300, + JSDocFunctionType = 301, + JSDocVariadicType = 302, + JSDocNamepathType = 303, + JSDocComment = 304, + JSDocTypeLiteral = 305, + JSDocSignature = 306, + JSDocTag = 307, + JSDocAugmentsTag = 308, + JSDocImplementsTag = 309, + JSDocAuthorTag = 310, + JSDocClassTag = 311, + JSDocPublicTag = 312, + JSDocPrivateTag = 313, + JSDocProtectedTag = 314, + JSDocReadonlyTag = 315, + JSDocCallbackTag = 316, + JSDocEnumTag = 317, + JSDocParameterTag = 318, + JSDocReturnTag = 319, + JSDocThisTag = 320, + JSDocTypeTag = 321, + JSDocTemplateTag = 322, + JSDocTypedefTag = 323, + JSDocPropertyTag = 324, + SyntaxList = 325, + NotEmittedStatement = 326, + PartiallyEmittedExpression = 327, + CommaListExpression = 328, + MergeDeclarationMarker = 329, + EndOfDeclarationMarker = 330, + SyntheticReferenceExpression = 331, + Count = 332, FirstAssignment = 62, LastAssignment = 74, FirstCompoundAssignment = 63, @@ -418,7 +419,7 @@ declare namespace ts { FirstFutureReservedWord = 113, LastFutureReservedWord = 121, FirstTypeNode = 168, - LastTypeNode = 188, + LastTypeNode = 189, FirstPunctuation = 18, LastPunctuation = 74, FirstToken = 0, @@ -431,13 +432,13 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 74, - FirstStatement = 225, - LastStatement = 241, + FirstStatement = 226, + LastStatement = 242, FirstNode = 153, - FirstJSDocNode = 294, - LastJSDocNode = 323, - FirstJSDocTagNode = 306, - LastJSDocTagNode = 323, + FirstJSDocNode = 295, + LastJSDocNode = 324, + FirstJSDocTagNode = 307, + LastJSDocTagNode = 324, } export enum NodeFlags { None = 0, @@ -508,7 +509,7 @@ declare namespace ts { } export interface JSDocContainer { } - export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | LabeledStatement | ExpressionStatement | VariableStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | EndOfFileToken; + export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | LabeledStatement | ExpressionStatement | VariableStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | NamedTupleMember | EndOfFileToken; export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType; export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement; export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute; @@ -809,7 +810,14 @@ declare namespace ts { } export interface TupleTypeNode extends TypeNode { kind: SyntaxKind.TupleType; - elementTypes: NodeArray; + elements: NodeArray; + } + export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration { + kind: SyntaxKind.NamedTupleMember; + dotDotDotToken?: Token; + name: Identifier; + questionToken?: Token; + type: TypeNode; } export interface OptionalTypeNode extends TypeNode { kind: SyntaxKind.OptionalType; @@ -947,6 +955,7 @@ declare namespace ts { kind: SyntaxKind.SyntheticExpression; isSpread: boolean; type: Type; + tupleNameSource?: ParameterDeclaration | NamedTupleMember; } export type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken; export type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken; @@ -1578,6 +1587,7 @@ declare namespace ts { text: string; pos: -1; end: -1; + hasLeadingNewline?: boolean; } export interface JSDocTypeExpression extends TypeNode { kind: SyntaxKind.JSDocTypeExpression; @@ -2466,7 +2476,7 @@ declare namespace ts { minLength: number; hasRestElement: boolean; readonly: boolean; - associatedNames?: __String[]; + labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]; } export interface TupleTypeReference extends TypeReference { target: TupleType; @@ -3223,7 +3233,8 @@ declare namespace ts { HeritageClauses = 512, SingleLineTypeLiteralMembers = 768, MultiLineTypeLiteralMembers = 32897, - TupleTypeElements = 528, + SingleLineTupleTypeElements = 528, + MultiLineTupleTypeElements = 657, UnionTypeConstituents = 516, IntersectionTypeConstituents = 520, ObjectBindingPatternElements = 525136, @@ -4043,8 +4054,8 @@ declare namespace ts { function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray): TypeLiteralNode; function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode; function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode; - function createTupleTypeNode(elementTypes: readonly TypeNode[]): TupleTypeNode; - function updateTupleTypeNode(node: TupleTypeNode, elementTypes: readonly TypeNode[]): TupleTypeNode; + function createTupleTypeNode(elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode; + function updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode; function createOptionalTypeNode(type: TypeNode): OptionalTypeNode; function updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode; function createRestTypeNode(type: TypeNode): RestTypeNode; @@ -4062,6 +4073,8 @@ declare namespace ts { function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode; function createParenthesizedType(type: TypeNode): ParenthesizedTypeNode; function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode; + function createNamedTupleMember(dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode): NamedTupleMember; + function updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode): NamedTupleMember; function createThisTypeNode(): ThisTypeNode; function createTypeOperatorNode(type: TypeNode): TypeOperatorNode; function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode; diff --git a/tests/baselines/reference/genericRestParameters1.types b/tests/baselines/reference/genericRestParameters1.types index c9067b38c974d..1503f11845964 100644 --- a/tests/baselines/reference/genericRestParameters1.types +++ b/tests/baselines/reference/genericRestParameters1.types @@ -665,7 +665,7 @@ const c30 = f30(42, x => "" + x, x => x + 1); // [(x: number) => string, (x: nu >1 : 1 type T01 = Parameters<(x: number, y: string, z: boolean) => void>; ->T01 : [number, string, boolean] +>T01 : [x: number, y: string, z: boolean] >x : number >y : string >z : boolean @@ -675,7 +675,7 @@ type T02 = Parameters<(...args: [number, string, boolean]) => void>; >args : [number, string, boolean] type T03 = ConstructorParameters void>; ->T03 : [number, string, boolean] +>T03 : [x: number, y: string, z: boolean] >x : number >y : string >z : boolean diff --git a/tests/baselines/reference/genericRestParameters2.types b/tests/baselines/reference/genericRestParameters2.types index 16798357a92a7..ec17e78625209 100644 --- a/tests/baselines/reference/genericRestParameters2.types +++ b/tests/baselines/reference/genericRestParameters2.types @@ -417,7 +417,7 @@ f20(42, "hello", ...t2, true); >true : true type T01 = Parameters<(x: number, y: string, ...z: boolean[]) => void>; ->T01 : [number, string, ...boolean[]] +>T01 : [x: number, y: string, ...z: boolean[]] >x : number >y : string >z : boolean[] @@ -427,7 +427,7 @@ type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>; >args : [number, string, ...boolean[]] type T03 = ConstructorParameters void>; ->T03 : [number, string, ...boolean[]] +>T03 : [x: number, y: string, ...z: boolean[]] >x : number >y : string >z : boolean[] @@ -452,7 +452,7 @@ type P1 = T extends (head: infer A, ...tail: infer B) => any >tail : B type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>; ->T10 : { head: number; tail: [string, ...boolean[]]; } +>T10 : { head: number; tail: [y: string, ...z: boolean[]]; } >x : number >y : string >z : boolean[] @@ -462,7 +462,7 @@ type T11 = P1<(...z: number[]) => void>; >z : number[] type T12 = P1<(x: number, y: number) => void>; ->T12 : { head: number; tail: [number]; } +>T12 : { head: number; tail: [y: number]; } >x : number >y : number diff --git a/tests/baselines/reference/genericRestParameters3.errors.txt b/tests/baselines/reference/genericRestParameters3.errors.txt index 9e3e9d97de42d..4b7032bb13b33 100644 --- a/tests/baselines/reference/genericRestParameters3.errors.txt +++ b/tests/baselines/reference/genericRestParameters3.errors.txt @@ -6,20 +6,20 @@ tests/cases/conformance/types/rest/genericRestParameters3.ts(18,1): error TS2345 tests/cases/conformance/types/rest/genericRestParameters3.ts(22,1): error TS2322: Type '(x: string, ...args: [string] | [number, boolean]) => void' is not assignable to type '(...args: [string, string] | [string, number, boolean]) => void'. tests/cases/conformance/types/rest/genericRestParameters3.ts(23,1): error TS2322: Type '(x: string, y: string) => void' is not assignable to type '(x: string, ...args: [string] | [number, boolean]) => void'. Types of parameters 'y' and 'args' are incompatible. - Type '[string] | [number, boolean]' is not assignable to type '[string]'. - Type '[number, boolean]' is not assignable to type '[string]'. + Type '[string] | [number, boolean]' is not assignable to type '[y: string]'. + Type '[number, boolean]' is not assignable to type '[y: string]'. Types of property '0' are incompatible. Type 'number' is not assignable to type 'string'. tests/cases/conformance/types/rest/genericRestParameters3.ts(24,1): error TS2322: Type '(x: string, y: number, z: boolean) => void' is not assignable to type '(x: string, ...args: [string] | [number, boolean]) => void'. Types of parameters 'y' and 'args' are incompatible. - Type '[string] | [number, boolean]' is not assignable to type '[number, boolean]'. - Property '1' is missing in type '[string]' but required in type '[number, boolean]'. + Type '[string] | [number, boolean]' is not assignable to type '[y: number, z: boolean]'. + Property '1' is missing in type '[string]' but required in type '[y: number, z: boolean]'. tests/cases/conformance/types/rest/genericRestParameters3.ts(25,1): error TS2322: Type '(...args: [string, string] | [string, number, boolean]) => void' is not assignable to type '(x: string, ...args: [string] | [number, boolean]) => void'. tests/cases/conformance/types/rest/genericRestParameters3.ts(35,1): error TS2554: Expected 1 arguments, but got 0. tests/cases/conformance/types/rest/genericRestParameters3.ts(36,21): error TS2345: Argument of type '100' is not assignable to parameter of type '(...args: CoolArray) => void'. tests/cases/conformance/types/rest/genericRestParameters3.ts(37,21): error TS2345: Argument of type '(cb: (...args: T) => void) => void' is not assignable to parameter of type '(...args: CoolArray) => void'. Types of parameters 'cb' and 'args' are incompatible. - Property '0' is missing in type 'CoolArray' but required in type '[(...args: any[]) => void]'. + Property '0' is missing in type 'CoolArray' but required in type '[cb: (...args: any[]) => void]'. tests/cases/conformance/types/rest/genericRestParameters3.ts(44,32): error TS2345: Argument of type '[10, 20]' is not assignable to parameter of type 'CoolArray'. Property 'hello' is missing in type '[10, 20]' but required in type 'CoolArray'. tests/cases/conformance/types/rest/genericRestParameters3.ts(49,1): error TS2345: Argument of type '[]' is not assignable to parameter of type 'CoolArray'. @@ -70,16 +70,16 @@ tests/cases/conformance/types/rest/genericRestParameters3.ts(59,5): error TS2345 ~~ !!! error TS2322: Type '(x: string, y: string) => void' is not assignable to type '(x: string, ...args: [string] | [number, boolean]) => void'. !!! error TS2322: Types of parameters 'y' and 'args' are incompatible. -!!! error TS2322: Type '[string] | [number, boolean]' is not assignable to type '[string]'. -!!! error TS2322: Type '[number, boolean]' is not assignable to type '[string]'. +!!! error TS2322: Type '[string] | [number, boolean]' is not assignable to type '[y: string]'. +!!! error TS2322: Type '[number, boolean]' is not assignable to type '[y: string]'. !!! error TS2322: Types of property '0' are incompatible. !!! error TS2322: Type 'number' is not assignable to type 'string'. f1 = f3; // Error ~~ !!! error TS2322: Type '(x: string, y: number, z: boolean) => void' is not assignable to type '(x: string, ...args: [string] | [number, boolean]) => void'. !!! error TS2322: Types of parameters 'y' and 'args' are incompatible. -!!! error TS2322: Type '[string] | [number, boolean]' is not assignable to type '[number, boolean]'. -!!! error TS2322: Property '1' is missing in type '[string]' but required in type '[number, boolean]'. +!!! error TS2322: Type '[string] | [number, boolean]' is not assignable to type '[y: number, z: boolean]'. +!!! error TS2322: Property '1' is missing in type '[string]' but required in type '[y: number, z: boolean]'. f1 = f4; // Error, misaligned complex rest types ~~ !!! error TS2322: Type '(...args: [string, string] | [string, number, boolean]) => void' is not assignable to type '(x: string, ...args: [string] | [number, boolean]) => void'. @@ -103,7 +103,7 @@ tests/cases/conformance/types/rest/genericRestParameters3.ts(59,5): error TS2345 ~~~ !!! error TS2345: Argument of type '(cb: (...args: T) => void) => void' is not assignable to parameter of type '(...args: CoolArray) => void'. !!! error TS2345: Types of parameters 'cb' and 'args' are incompatible. -!!! error TS2345: Property '0' is missing in type 'CoolArray' but required in type '[(...args: any[]) => void]'. +!!! error TS2345: Property '0' is missing in type 'CoolArray' but required in type '[cb: (...args: any[]) => void]'. function bar(...args: T): T { return args; diff --git a/tests/baselines/reference/genericRestTypes.errors.txt b/tests/baselines/reference/genericRestTypes.errors.txt index c0fcb85e49201..0df6490b6a22d 100644 --- a/tests/baselines/reference/genericRestTypes.errors.txt +++ b/tests/baselines/reference/genericRestTypes.errors.txt @@ -1,7 +1,7 @@ tests/cases/compiler/genericRestTypes.ts(21,11): error TS2322: Type '(cb: (x: string, ...rest: T) => void) => void' is not assignable to type '(cb: (...args: never) => void) => void'. Types of parameters 'cb' and 'cb' are incompatible. Types of parameters 'args' and 'x' are incompatible. - Type '[string, ...T[number][]]' is not assignable to type 'never'. + Type '[x: string, ...rest: T[number][]]' is not assignable to type 'never'. ==== tests/cases/compiler/genericRestTypes.ts (1 errors) ==== @@ -30,7 +30,7 @@ tests/cases/compiler/genericRestTypes.ts(21,11): error TS2322: Type '(cb: (x: st !!! error TS2322: Type '(cb: (x: string, ...rest: T) => void) => void' is not assignable to type '(cb: (...args: never) => void) => void'. !!! error TS2322: Types of parameters 'cb' and 'cb' are incompatible. !!! error TS2322: Types of parameters 'args' and 'x' are incompatible. -!!! error TS2322: Type '[string, ...T[number][]]' is not assignable to type 'never'. +!!! error TS2322: Type '[x: string, ...rest: T[number][]]' is not assignable to type 'never'. } function assignmentWithComplexRest3() { diff --git a/tests/baselines/reference/genericRestTypes.types b/tests/baselines/reference/genericRestTypes.types index 8d06f4a07732a..d46f303548154 100644 --- a/tests/baselines/reference/genericRestTypes.types +++ b/tests/baselines/reference/genericRestTypes.types @@ -16,7 +16,7 @@ type MyFunctionType = (foo: number, bar: string) => boolean; type Explicit = (...args: Tail>) => ReturnType; // (bar: string) => boolean >Explicit : Explicit ->args : [string] +>args : [bar: string] type Bind1 any> = (...args: Tail>) => ReturnType; >Bind1 : Bind1 diff --git a/tests/baselines/reference/getParameterNameAtPosition.types b/tests/baselines/reference/getParameterNameAtPosition.types index f722d7e5f9533..1e0c92129010b 100644 --- a/tests/baselines/reference/getParameterNameAtPosition.types +++ b/tests/baselines/reference/getParameterNameAtPosition.types @@ -23,7 +23,7 @@ declare function fn(implementation?: (...args: Y) => any): Mock cases(fn(opts => { })); >cases(fn(opts => { })) : void >cases : (tester: Tester) => void ->fn(opts => { }) : Mock<[any]> +>fn(opts => { }) : Mock<[opts: any]> >fn : (implementation?: ((...args: Y) => any) | undefined) => Mock >opts => { } : (opts: any) => void >opts : any diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types index b5317b6f7561f..d6c380cb7ac6f 100644 --- a/tests/baselines/reference/instantiateContextualTypes.types +++ b/tests/baselines/reference/instantiateContextualTypes.types @@ -444,5 +444,5 @@ assignPartial(obj, { foo(...args) {} }); // args has type [string] >obj : { foo(bar: string): void; } >{ foo(...args) {} } : { foo(bar: string): void; } >foo : (bar: string) => void ->args : [string] +>args : [bar: string] diff --git a/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types b/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types index 27d8e5a4cb4ed..435bdc4c4cf93 100644 --- a/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types +++ b/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types @@ -33,7 +33,7 @@ function consumeClass(c: GenericClass<[string, boolean]>) { } consumeClass(createClass(str => console.log(str.length))); >consumeClass(createClass(str => console.log(str.length))) : void >consumeClass : (c: GenericClass<[string, boolean]>) => void ->createClass(str => console.log(str.length)) : GenericClass<[string]> +>createClass(str => console.log(str.length)) : GenericClass<[str: string]> >createClass : (f: GenericFunction) => GenericClass >str => console.log(str.length) : (str: string) => void >str : string @@ -49,7 +49,7 @@ consumeClass(createClass(str => console.log(str.length))); consumeClass(createClass((str, _unused_num) => console.log(str.length))); >consumeClass(createClass((str, _unused_num) => console.log(str.length))) : void >consumeClass : (c: GenericClass<[string, boolean]>) => void ->createClass((str, _unused_num) => console.log(str.length)) : GenericClass<[string, boolean]> +>createClass((str, _unused_num) => console.log(str.length)) : GenericClass<[str: string, _unused_num: boolean]> >createClass : (f: GenericFunction) => GenericClass >(str, _unused_num) => console.log(str.length) : (str: string, _unused_num: boolean) => void >str : string diff --git a/tests/baselines/reference/namedTupleMembers.js b/tests/baselines/reference/namedTupleMembers.js new file mode 100644 index 0000000000000..9095259eec95a --- /dev/null +++ b/tests/baselines/reference/namedTupleMembers.js @@ -0,0 +1,140 @@ +//// [namedTupleMembers.ts] +export type Segment = [length: number, count: number]; + +export type SegmentAnnotated = [ + /** + * Size of message buffer segment handles + */ + length: number, + /** + * Number of segments handled at once + */ + count: number +]; + +declare var a: Segment; +declare var b: SegmentAnnotated; +declare var c: [number, number]; +declare var d: [a: number, b: number]; + +a = b; +a = c; +a = d; + +b = a; +b = c; +b = d; + +c = a; +c = b; +c = d; + +d = a; +d = b; +d = c; + +export type WithOptAndRest = [first: number, second?: number, ...rest: string[]]; + +export type Func = (...x: T) => void; + +export const func = null as any as Func; + +export function useState(initial: T): [value: T, setter: (T) => void] { + return null as any; +} + + +export type Iter = Func<[step: number, iterations: number]>; + +export function readSegment([length, count]: [number, number]) {} + +// documenting binding pattern behavior (currently does _not_ generate tuple names) +export const val = null as any as Parameters[0]; + +export type RecursiveTupleA = [initial: string, next: RecursiveTupleA]; + +export type RecursiveTupleB = [first: string, ptr: RecursiveTupleB]; + +declare var q: RecursiveTupleA; +declare var r: RecursiveTupleB; + +q = r; +r = q; + +export type RecusiveRest = [first: string, ...rest: RecusiveRest[]]; +export type RecusiveRest2 = [string, ...RecusiveRest2[]]; + +declare var x: RecusiveRest; +declare var y: RecusiveRest2; + +x = y; +y = x; + +declare function f(...x: T): T; +declare function g(elem: object, index: number): object; +declare function getArgsForInjection any>(x: T): Parameters; + +export const argumentsOfGAsFirstArgument = f(getArgsForInjection(g)); // one tuple with captures arguments as first member +export const argumentsOfG = f(...getArgsForInjection(g)); // captured arguments list re-spread + + +//// [namedTupleMembers.js] +"use strict"; +exports.__esModule = true; +exports.argumentsOfG = exports.argumentsOfGAsFirstArgument = exports.val = exports.readSegment = exports.useState = exports.func = void 0; +a = b; +a = c; +a = d; +b = a; +b = c; +b = d; +c = a; +c = b; +c = d; +d = a; +d = b; +d = c; +exports.func = null; +function useState(initial) { + return null; +} +exports.useState = useState; +function readSegment(_a) { + var length = _a[0], count = _a[1]; +} +exports.readSegment = readSegment; +// documenting binding pattern behavior (currently does _not_ generate tuple names) +exports.val = null; +q = r; +r = q; +x = y; +y = x; +exports.argumentsOfGAsFirstArgument = f(getArgsForInjection(g)); // one tuple with captures arguments as first member +exports.argumentsOfG = f.apply(void 0, getArgsForInjection(g)); // captured arguments list re-spread + + +//// [namedTupleMembers.d.ts] +export declare type Segment = [length: number, count: number]; +export declare type SegmentAnnotated = [ + /** + * Size of message buffer segment handles + */ + length: number, + /** + * Number of segments handled at once + */ + count: number +]; +export declare type WithOptAndRest = [first: number, second?: number, ...rest: string[]]; +export declare type Func = (...x: T) => void; +export declare const func: Func; +export declare function useState(initial: T): [value: T, setter: (T: any) => void]; +export declare type Iter = Func<[step: number, iterations: number]>; +export declare function readSegment([length, count]: [number, number]): void; +export declare const val: [number, number]; +export declare type RecursiveTupleA = [initial: string, next: RecursiveTupleA]; +export declare type RecursiveTupleB = [first: string, ptr: RecursiveTupleB]; +export declare type RecusiveRest = [first: string, ...rest: RecusiveRest[]]; +export declare type RecusiveRest2 = [string, ...RecusiveRest2[]]; +export declare const argumentsOfGAsFirstArgument: [[elem: object, index: number]]; +export declare const argumentsOfG: [elem: object, index: number]; diff --git a/tests/baselines/reference/namedTupleMembers.symbols b/tests/baselines/reference/namedTupleMembers.symbols new file mode 100644 index 0000000000000..a7d40391c8f52 --- /dev/null +++ b/tests/baselines/reference/namedTupleMembers.symbols @@ -0,0 +1,201 @@ +=== tests/cases/conformance/types/tuple/named/namedTupleMembers.ts === +export type Segment = [length: number, count: number]; +>Segment : Symbol(Segment, Decl(namedTupleMembers.ts, 0, 0)) + +export type SegmentAnnotated = [ +>SegmentAnnotated : Symbol(SegmentAnnotated, Decl(namedTupleMembers.ts, 0, 54)) + + /** + * Size of message buffer segment handles + */ + length: number, + /** + * Number of segments handled at once + */ + count: number +]; + +declare var a: Segment; +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) +>Segment : Symbol(Segment, Decl(namedTupleMembers.ts, 0, 0)) + +declare var b: SegmentAnnotated; +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) +>SegmentAnnotated : Symbol(SegmentAnnotated, Decl(namedTupleMembers.ts, 0, 54)) + +declare var c: [number, number]; +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) + +declare var d: [a: number, b: number]; +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) + +a = b; +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) + +a = c; +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) + +a = d; +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) + +b = a; +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) + +b = c; +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) + +b = d; +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) + +c = a; +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) + +c = b; +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) + +c = d; +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) + +d = a; +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) +>a : Symbol(a, Decl(namedTupleMembers.ts, 13, 11)) + +d = b; +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) +>b : Symbol(b, Decl(namedTupleMembers.ts, 14, 11)) + +d = c; +>d : Symbol(d, Decl(namedTupleMembers.ts, 16, 11)) +>c : Symbol(c, Decl(namedTupleMembers.ts, 15, 11)) + +export type WithOptAndRest = [first: number, second?: number, ...rest: string[]]; +>WithOptAndRest : Symbol(WithOptAndRest, Decl(namedTupleMembers.ts, 32, 6)) + +export type Func = (...x: T) => void; +>Func : Symbol(Func, Decl(namedTupleMembers.ts, 34, 81)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 36, 17)) +>x : Symbol(x, Decl(namedTupleMembers.ts, 36, 37)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 36, 17)) + +export const func = null as any as Func; +>func : Symbol(func, Decl(namedTupleMembers.ts, 38, 12)) +>Func : Symbol(Func, Decl(namedTupleMembers.ts, 34, 81)) +>SegmentAnnotated : Symbol(SegmentAnnotated, Decl(namedTupleMembers.ts, 0, 54)) + +export function useState(initial: T): [value: T, setter: (T) => void] { +>useState : Symbol(useState, Decl(namedTupleMembers.ts, 38, 58)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 40, 25)) +>initial : Symbol(initial, Decl(namedTupleMembers.ts, 40, 28)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 40, 25)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 40, 25)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 40, 61)) + + return null as any; +} + + +export type Iter = Func<[step: number, iterations: number]>; +>Iter : Symbol(Iter, Decl(namedTupleMembers.ts, 42, 1)) +>Func : Symbol(Func, Decl(namedTupleMembers.ts, 34, 81)) + +export function readSegment([length, count]: [number, number]) {} +>readSegment : Symbol(readSegment, Decl(namedTupleMembers.ts, 45, 60)) +>length : Symbol(length, Decl(namedTupleMembers.ts, 47, 29)) +>count : Symbol(count, Decl(namedTupleMembers.ts, 47, 36)) + +// documenting binding pattern behavior (currently does _not_ generate tuple names) +export const val = null as any as Parameters[0]; +>val : Symbol(val, Decl(namedTupleMembers.ts, 50, 12)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>readSegment : Symbol(readSegment, Decl(namedTupleMembers.ts, 45, 60)) + +export type RecursiveTupleA = [initial: string, next: RecursiveTupleA]; +>RecursiveTupleA : Symbol(RecursiveTupleA, Decl(namedTupleMembers.ts, 50, 68)) +>RecursiveTupleA : Symbol(RecursiveTupleA, Decl(namedTupleMembers.ts, 50, 68)) + +export type RecursiveTupleB = [first: string, ptr: RecursiveTupleB]; +>RecursiveTupleB : Symbol(RecursiveTupleB, Decl(namedTupleMembers.ts, 52, 71)) +>RecursiveTupleB : Symbol(RecursiveTupleB, Decl(namedTupleMembers.ts, 52, 71)) + +declare var q: RecursiveTupleA; +>q : Symbol(q, Decl(namedTupleMembers.ts, 56, 11)) +>RecursiveTupleA : Symbol(RecursiveTupleA, Decl(namedTupleMembers.ts, 50, 68)) + +declare var r: RecursiveTupleB; +>r : Symbol(r, Decl(namedTupleMembers.ts, 57, 11)) +>RecursiveTupleB : Symbol(RecursiveTupleB, Decl(namedTupleMembers.ts, 52, 71)) + +q = r; +>q : Symbol(q, Decl(namedTupleMembers.ts, 56, 11)) +>r : Symbol(r, Decl(namedTupleMembers.ts, 57, 11)) + +r = q; +>r : Symbol(r, Decl(namedTupleMembers.ts, 57, 11)) +>q : Symbol(q, Decl(namedTupleMembers.ts, 56, 11)) + +export type RecusiveRest = [first: string, ...rest: RecusiveRest[]]; +>RecusiveRest : Symbol(RecusiveRest, Decl(namedTupleMembers.ts, 60, 6)) +>RecusiveRest : Symbol(RecusiveRest, Decl(namedTupleMembers.ts, 60, 6)) + +export type RecusiveRest2 = [string, ...RecusiveRest2[]]; +>RecusiveRest2 : Symbol(RecusiveRest2, Decl(namedTupleMembers.ts, 62, 68)) +>RecusiveRest2 : Symbol(RecusiveRest2, Decl(namedTupleMembers.ts, 62, 68)) + +declare var x: RecusiveRest; +>x : Symbol(x, Decl(namedTupleMembers.ts, 65, 11)) +>RecusiveRest : Symbol(RecusiveRest, Decl(namedTupleMembers.ts, 60, 6)) + +declare var y: RecusiveRest2; +>y : Symbol(y, Decl(namedTupleMembers.ts, 66, 11)) +>RecusiveRest2 : Symbol(RecusiveRest2, Decl(namedTupleMembers.ts, 62, 68)) + +x = y; +>x : Symbol(x, Decl(namedTupleMembers.ts, 65, 11)) +>y : Symbol(y, Decl(namedTupleMembers.ts, 66, 11)) + +y = x; +>y : Symbol(y, Decl(namedTupleMembers.ts, 66, 11)) +>x : Symbol(x, Decl(namedTupleMembers.ts, 65, 11)) + +declare function f(...x: T): T; +>f : Symbol(f, Decl(namedTupleMembers.ts, 69, 6)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 71, 19)) +>x : Symbol(x, Decl(namedTupleMembers.ts, 71, 36)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 71, 19)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 71, 19)) + +declare function g(elem: object, index: number): object; +>g : Symbol(g, Decl(namedTupleMembers.ts, 71, 48)) +>elem : Symbol(elem, Decl(namedTupleMembers.ts, 72, 19)) +>index : Symbol(index, Decl(namedTupleMembers.ts, 72, 32)) + +declare function getArgsForInjection any>(x: T): Parameters; +>getArgsForInjection : Symbol(getArgsForInjection, Decl(namedTupleMembers.ts, 72, 56)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 73, 37)) +>args : Symbol(args, Decl(namedTupleMembers.ts, 73, 48)) +>x : Symbol(x, Decl(namedTupleMembers.ts, 73, 72)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 73, 37)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(namedTupleMembers.ts, 73, 37)) + +export const argumentsOfGAsFirstArgument = f(getArgsForInjection(g)); // one tuple with captures arguments as first member +>argumentsOfGAsFirstArgument : Symbol(argumentsOfGAsFirstArgument, Decl(namedTupleMembers.ts, 75, 12)) +>f : Symbol(f, Decl(namedTupleMembers.ts, 69, 6)) +>getArgsForInjection : Symbol(getArgsForInjection, Decl(namedTupleMembers.ts, 72, 56)) +>g : Symbol(g, Decl(namedTupleMembers.ts, 71, 48)) + +export const argumentsOfG = f(...getArgsForInjection(g)); // captured arguments list re-spread +>argumentsOfG : Symbol(argumentsOfG, Decl(namedTupleMembers.ts, 76, 12)) +>f : Symbol(f, Decl(namedTupleMembers.ts, 69, 6)) +>getArgsForInjection : Symbol(getArgsForInjection, Decl(namedTupleMembers.ts, 72, 56)) +>g : Symbol(g, Decl(namedTupleMembers.ts, 71, 48)) + diff --git a/tests/baselines/reference/namedTupleMembers.types b/tests/baselines/reference/namedTupleMembers.types new file mode 100644 index 0000000000000..14badf44552db --- /dev/null +++ b/tests/baselines/reference/namedTupleMembers.types @@ -0,0 +1,204 @@ +=== tests/cases/conformance/types/tuple/named/namedTupleMembers.ts === +export type Segment = [length: number, count: number]; +>Segment : Segment + +export type SegmentAnnotated = [ +>SegmentAnnotated : SegmentAnnotated + + /** + * Size of message buffer segment handles + */ + length: number, + /** + * Number of segments handled at once + */ + count: number +]; + +declare var a: Segment; +>a : Segment + +declare var b: SegmentAnnotated; +>b : SegmentAnnotated + +declare var c: [number, number]; +>c : [number, number] + +declare var d: [a: number, b: number]; +>d : [a: number, b: number] + +a = b; +>a = b : SegmentAnnotated +>a : Segment +>b : SegmentAnnotated + +a = c; +>a = c : [number, number] +>a : Segment +>c : [number, number] + +a = d; +>a = d : [a: number, b: number] +>a : Segment +>d : [a: number, b: number] + +b = a; +>b = a : Segment +>b : SegmentAnnotated +>a : Segment + +b = c; +>b = c : [number, number] +>b : SegmentAnnotated +>c : [number, number] + +b = d; +>b = d : [a: number, b: number] +>b : SegmentAnnotated +>d : [a: number, b: number] + +c = a; +>c = a : Segment +>c : [number, number] +>a : Segment + +c = b; +>c = b : SegmentAnnotated +>c : [number, number] +>b : SegmentAnnotated + +c = d; +>c = d : [a: number, b: number] +>c : [number, number] +>d : [a: number, b: number] + +d = a; +>d = a : Segment +>d : [a: number, b: number] +>a : Segment + +d = b; +>d = b : SegmentAnnotated +>d : [a: number, b: number] +>b : SegmentAnnotated + +d = c; +>d = c : [number, number] +>d : [a: number, b: number] +>c : [number, number] + +export type WithOptAndRest = [first: number, second?: number, ...rest: string[]]; +>WithOptAndRest : WithOptAndRest + +export type Func = (...x: T) => void; +>Func : Func +>x : T + +export const func = null as any as Func; +>func : Func +>null as any as Func : Func +>null as any : any +>null : null + +export function useState(initial: T): [value: T, setter: (T) => void] { +>useState : (initial: T) => [value: T, setter: (T: any) => void] +>initial : T +>T : any + + return null as any; +>null as any : any +>null : null +} + + +export type Iter = Func<[step: number, iterations: number]>; +>Iter : Func<[step: number, iterations: number]> + +export function readSegment([length, count]: [number, number]) {} +>readSegment : ([length, count]: [number, number]) => void +>length : number +>count : number + +// documenting binding pattern behavior (currently does _not_ generate tuple names) +export const val = null as any as Parameters[0]; +>val : [number, number] +>null as any as Parameters[0] : [number, number] +>null as any : any +>null : null +>readSegment : ([length, count]: [number, number]) => void + +export type RecursiveTupleA = [initial: string, next: RecursiveTupleA]; +>RecursiveTupleA : RecursiveTupleA + +export type RecursiveTupleB = [first: string, ptr: RecursiveTupleB]; +>RecursiveTupleB : RecursiveTupleB + +declare var q: RecursiveTupleA; +>q : RecursiveTupleA + +declare var r: RecursiveTupleB; +>r : RecursiveTupleB + +q = r; +>q = r : RecursiveTupleB +>q : RecursiveTupleA +>r : RecursiveTupleB + +r = q; +>r = q : RecursiveTupleA +>r : RecursiveTupleB +>q : RecursiveTupleA + +export type RecusiveRest = [first: string, ...rest: RecusiveRest[]]; +>RecusiveRest : RecusiveRest + +export type RecusiveRest2 = [string, ...RecusiveRest2[]]; +>RecusiveRest2 : RecusiveRest2 + +declare var x: RecusiveRest; +>x : RecusiveRest + +declare var y: RecusiveRest2; +>y : RecusiveRest2 + +x = y; +>x = y : RecusiveRest2 +>x : RecusiveRest +>y : RecusiveRest2 + +y = x; +>y = x : RecusiveRest +>y : RecusiveRest2 +>x : RecusiveRest + +declare function f(...x: T): T; +>f : (...x: T) => T +>x : T + +declare function g(elem: object, index: number): object; +>g : (elem: object, index: number) => object +>elem : object +>index : number + +declare function getArgsForInjection any>(x: T): Parameters; +>getArgsForInjection : any>(x: T) => Parameters +>args : any[] +>x : T + +export const argumentsOfGAsFirstArgument = f(getArgsForInjection(g)); // one tuple with captures arguments as first member +>argumentsOfGAsFirstArgument : [[elem: object, index: number]] +>f(getArgsForInjection(g)) : [[elem: object, index: number]] +>f : (...x: T) => T +>getArgsForInjection(g) : [elem: object, index: number] +>getArgsForInjection : any>(x: T) => Parameters +>g : (elem: object, index: number) => object + +export const argumentsOfG = f(...getArgsForInjection(g)); // captured arguments list re-spread +>argumentsOfG : [elem: object, index: number] +>f(...getArgsForInjection(g)) : [elem: object, index: number] +>f : (...x: T) => T +>...getArgsForInjection(g) : number | object +>getArgsForInjection(g) : [elem: object, index: number] +>getArgsForInjection : any>(x: T) => Parameters +>g : (elem: object, index: number) => object + diff --git a/tests/baselines/reference/namedTupleMembersErrors.errors.txt b/tests/baselines/reference/namedTupleMembersErrors.errors.txt new file mode 100644 index 0000000000000..19e40ba93719a --- /dev/null +++ b/tests/baselines/reference/namedTupleMembersErrors.errors.txt @@ -0,0 +1,55 @@ +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(1,41): error TS5084: Tuple members must all have names or all not have names. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(3,32): error TS5084: Tuple members must all have names or all not have names. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(5,32): error TS5084: Tuple members must all have names or all not have names. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(7,29): error TS5086: A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(9,46): error TS5087: A labeled tuple element is declared as rest with a `...` before the name, rather than before the type. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(11,49): error TS5087: A labeled tuple element is declared as rest with a `...` before the name, rather than before the type. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(11,52): error TS8020: JSDoc types can only be used inside documentation comments. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(13,39): error TS5085: A tuple member cannot be both optional and rest. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(15,44): error TS2574: A rest element type must be an array type. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(17,46): error TS2574: A rest element type must be an array type. +tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts(18,44): error TS2574: A rest element type must be an array type. + + +==== tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts (11 errors) ==== + export type Segment1 = [length: number, number]; // partially named, disallowed + ~~~~~~ +!!! error TS5084: Tuple members must all have names or all not have names. + + export type List = [item: any, ...any]; // partially named, disallowed + ~~~~~~ +!!! error TS5084: Tuple members must all have names or all not have names. + + export type Pair = [item: any, any?]; // partially named, disallowed + ~~~~ +!!! error TS5084: Tuple members must all have names or all not have names. + + export type Opt = [element: string?]; // question mark on element disallowed + ~~~~~~~ +!!! error TS5086: A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type. + + export type Trailing = [first: string, rest: ...string[]]; // dots on element disallowed + ~~~~~~~~~~~ +!!! error TS5087: A labeled tuple element is declared as rest with a `...` before the name, rather than before the type. + + export type OptTrailing = [first: string, rest: ...string[]?]; // dots+question on element disallowed + ~~~~~~~~~~~~ +!!! error TS5087: A labeled tuple element is declared as rest with a `...` before the name, rather than before the type. + ~~~~~~~~~ +!!! error TS8020: JSDoc types can only be used inside documentation comments. + + export type OptRest = [first: string, ...rest?: string[]]; // rest+optional disallowed + ~~~~~~~~~~~~~~~~~~ +!!! error TS5085: A tuple member cannot be both optional and rest. + + export type NonArrayRest = [first: string, ...rest: number]; // non-arraylike rest, disallowed + ~~~~~~~~~~~~~~~ +!!! error TS2574: A rest element type must be an array type. + + export type RecusiveRestUnlabeled = [string, ...RecusiveRestUnlabeled]; + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2574: A rest element type must be an array type. + export type RecusiveRest = [first: string, ...rest: RecusiveRest]; // marked as incorrect, same as above + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2574: A rest element type must be an array type. + \ No newline at end of file diff --git a/tests/baselines/reference/namedTupleMembersErrors.js b/tests/baselines/reference/namedTupleMembersErrors.js new file mode 100644 index 0000000000000..5b277b3efe05c --- /dev/null +++ b/tests/baselines/reference/namedTupleMembersErrors.js @@ -0,0 +1,37 @@ +//// [namedTupleMembersErrors.ts] +export type Segment1 = [length: number, number]; // partially named, disallowed + +export type List = [item: any, ...any]; // partially named, disallowed + +export type Pair = [item: any, any?]; // partially named, disallowed + +export type Opt = [element: string?]; // question mark on element disallowed + +export type Trailing = [first: string, rest: ...string[]]; // dots on element disallowed + +export type OptTrailing = [first: string, rest: ...string[]?]; // dots+question on element disallowed + +export type OptRest = [first: string, ...rest?: string[]]; // rest+optional disallowed + +export type NonArrayRest = [first: string, ...rest: number]; // non-arraylike rest, disallowed + +export type RecusiveRestUnlabeled = [string, ...RecusiveRestUnlabeled]; +export type RecusiveRest = [first: string, ...rest: RecusiveRest]; // marked as incorrect, same as above + + +//// [namedTupleMembersErrors.js] +"use strict"; +exports.__esModule = true; + + +//// [namedTupleMembersErrors.d.ts] +export declare type Segment1 = [length: number, number]; +export declare type List = [item: any, ...any]; +export declare type Pair = [item: any, any?]; +export declare type Opt = [element: string?]; +export declare type Trailing = [first: string, rest: ...string[]]; +export declare type OptTrailing = [first: string, rest: ...?string[]]; +export declare type OptRest = [first: string, ...rest?: string[]]; +export declare type NonArrayRest = [first: string, ...rest: number]; +export declare type RecusiveRestUnlabeled = [string, ...RecusiveRestUnlabeled]; +export declare type RecusiveRest = [first: string, ...rest: RecusiveRest]; diff --git a/tests/baselines/reference/namedTupleMembersErrors.symbols b/tests/baselines/reference/namedTupleMembersErrors.symbols new file mode 100644 index 0000000000000..613bf86cddd0e --- /dev/null +++ b/tests/baselines/reference/namedTupleMembersErrors.symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts === +export type Segment1 = [length: number, number]; // partially named, disallowed +>Segment1 : Symbol(Segment1, Decl(namedTupleMembersErrors.ts, 0, 0)) + +export type List = [item: any, ...any]; // partially named, disallowed +>List : Symbol(List, Decl(namedTupleMembersErrors.ts, 0, 48)) + +export type Pair = [item: any, any?]; // partially named, disallowed +>Pair : Symbol(Pair, Decl(namedTupleMembersErrors.ts, 2, 39)) + +export type Opt = [element: string?]; // question mark on element disallowed +>Opt : Symbol(Opt, Decl(namedTupleMembersErrors.ts, 4, 37)) + +export type Trailing = [first: string, rest: ...string[]]; // dots on element disallowed +>Trailing : Symbol(Trailing, Decl(namedTupleMembersErrors.ts, 6, 37)) + +export type OptTrailing = [first: string, rest: ...string[]?]; // dots+question on element disallowed +>OptTrailing : Symbol(OptTrailing, Decl(namedTupleMembersErrors.ts, 8, 58)) + +export type OptRest = [first: string, ...rest?: string[]]; // rest+optional disallowed +>OptRest : Symbol(OptRest, Decl(namedTupleMembersErrors.ts, 10, 62)) + +export type NonArrayRest = [first: string, ...rest: number]; // non-arraylike rest, disallowed +>NonArrayRest : Symbol(NonArrayRest, Decl(namedTupleMembersErrors.ts, 12, 58)) + +export type RecusiveRestUnlabeled = [string, ...RecusiveRestUnlabeled]; +>RecusiveRestUnlabeled : Symbol(RecusiveRestUnlabeled, Decl(namedTupleMembersErrors.ts, 14, 60)) +>RecusiveRestUnlabeled : Symbol(RecusiveRestUnlabeled, Decl(namedTupleMembersErrors.ts, 14, 60)) + +export type RecusiveRest = [first: string, ...rest: RecusiveRest]; // marked as incorrect, same as above +>RecusiveRest : Symbol(RecusiveRest, Decl(namedTupleMembersErrors.ts, 16, 71)) +>RecusiveRest : Symbol(RecusiveRest, Decl(namedTupleMembersErrors.ts, 16, 71)) + diff --git a/tests/baselines/reference/namedTupleMembersErrors.types b/tests/baselines/reference/namedTupleMembersErrors.types new file mode 100644 index 0000000000000..3285a453592ba --- /dev/null +++ b/tests/baselines/reference/namedTupleMembersErrors.types @@ -0,0 +1,31 @@ +=== tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts === +export type Segment1 = [length: number, number]; // partially named, disallowed +>Segment1 : Segment1 + +export type List = [item: any, ...any]; // partially named, disallowed +>List : List + +export type Pair = [item: any, any?]; // partially named, disallowed +>Pair : Pair + +export type Opt = [element: string?]; // question mark on element disallowed +>Opt : Opt + +export type Trailing = [first: string, rest: ...string[]]; // dots on element disallowed +>Trailing : Trailing + +export type OptTrailing = [first: string, rest: ...string[]?]; // dots+question on element disallowed +>OptTrailing : OptTrailing + +export type OptRest = [first: string, ...rest?: string[]]; // rest+optional disallowed +>OptRest : OptRest + +export type NonArrayRest = [first: string, ...rest: number]; // non-arraylike rest, disallowed +>NonArrayRest : NonArrayRest + +export type RecusiveRestUnlabeled = [string, ...RecusiveRestUnlabeled]; +>RecusiveRestUnlabeled : RecusiveRestUnlabeled + +export type RecusiveRest = [first: string, ...rest: RecusiveRest]; // marked as incorrect, same as above +>RecusiveRest : RecusiveRest + diff --git a/tests/baselines/reference/parameterListAsTupleType.types b/tests/baselines/reference/parameterListAsTupleType.types index 3bb861f5a1deb..0412ab7f75fe5 100644 --- a/tests/baselines/reference/parameterListAsTupleType.types +++ b/tests/baselines/reference/parameterListAsTupleType.types @@ -8,7 +8,7 @@ function foo(a: number, b: string) { >true : true } type Foops = Parameters; ->Foops : [number, string] +>Foops : [a: number, b: string] >foo : (a: number, b: string) => boolean const x = (a: number) => 5; @@ -18,17 +18,17 @@ const x = (a: number) => 5; >5 : 5 type Xps = Parameters; ->Xps : [number] +>Xps : [a: number] >x : (a: number) => number const a: Xps = ['should-not-work']; // works, but shouldn't ->a : [number] +>a : [a: number] >['should-not-work'] : [string] >'should-not-work' : "should-not-work" function t(...args: Xps) {} // should work >t : (a: number) => void ->args : [number] +>args : [a: number] class C { >C : C @@ -44,7 +44,7 @@ type Cps = Parameters; // should not work >C : typeof C type Ccps = ConstructorParameters; // should be [number, string] ->Ccps : [number, string] +>Ccps : [a: number, b: string] >C : typeof C class D { @@ -56,6 +56,6 @@ class D { } } type Dcps = ConstructorParameters; // should be [number, ...string[]] ->Dcps : [number, ...string[]] +>Dcps : [a: number, ...rest: string[]] >D : typeof D diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types b/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types index 94eabc48b8f0a..3f49d1ac95a33 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types +++ b/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types @@ -105,7 +105,7 @@ testRest((t2: D, ...t3) => {}) >testRest : (a: (t: T, t1: T, ...ts: T[]) => void) => T >(t2: D, ...t3) => {} : (t2: D, t1: D, ...ts: D[]) => void >t2 : D ->t3 : [D, ...D[]] +>t3 : [t1: D, ...ts: D[]] testRest((t2, ...t3: D[]) => {}) >testRest((t2, ...t3: D[]) => {}) : C diff --git a/tests/baselines/reference/ramdaToolsNoInfinite.types b/tests/baselines/reference/ramdaToolsNoInfinite.types index 229bdfe4c4053..d6ac7f2da1e51 100644 --- a/tests/baselines/reference/ramdaToolsNoInfinite.types +++ b/tests/baselines/reference/ramdaToolsNoInfinite.types @@ -128,12 +128,12 @@ declare namespace Tools { ]; type Concat = ->Concat : { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends (any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[9], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[8], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[7], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>>>>; }[10 extends ({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[8], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[7], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>>>; }[9 extends ({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[7], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>>; }[8 extends ({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>; }[7 extends ({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>; }[6 extends ({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>; }[5 extends ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>; }[4 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>; }[3 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>; }[2 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T1["length"] ? 1 : 0]; 1: [T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T1["length"] ? 1 : 0]; 1: [T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>; }[1 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[10 extends T1["length"] ? 1 : 0]; 1: [T1[8], T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[9 extends T1["length"] ? 1 : 0]; 1: [T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: T2; }[0 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends T1["length"] ? 1 : 0]; 1: [T1[9], T1[8], T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[10 extends T1["length"] ? 1 : 0]; 1: [T1[8], T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[9 extends T1["length"] ? 1 : 0]; 1: [T1[7], T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [T1[6], T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [T1[5], T1[4], T1[3], T1[2], T1[1], T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [T1[4], T1[3], T1[2], T1[1], T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [T1[3], T1[2], T1[1], T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [T1[2], T1[1], T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [T1[1], T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0] +>Concat : { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends (any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[9], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[8], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[7], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<(any[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>>>>; }[10 extends ({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[8], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[7], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: any[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>>>; }[9 extends ({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[7], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: any[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>>; }[8 extends ({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[6], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: any[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>>; }[7 extends ({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[5], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: any[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>>; }[6 extends ({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[4], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: any[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>>; }[5 extends ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[3], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>>; }[4 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[2], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>>; }[3 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[1], Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>>; }[2 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T1["length"] ? 1 : 0]; 1: [head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: Prepend<({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T1["length"] ? 1 : 0]; 1: [head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)[0], T2>; }[1 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[10 extends T1["length"] ? 1 : 0]; 1: [head: T1[8], head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[9 extends T1["length"] ? 1 : 0]; 1: [head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: T2; }[0 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends T1["length"] ? 1 : 0]; 1: [head: T1[9], head: T1[8], head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[10 extends T1["length"] ? 1 : 0]; 1: [head: T1[8], head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[9 extends T1["length"] ? 1 : 0]; 1: [head: T1[7], head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[8 extends T1["length"] ? 1 : 0]; 1: [head: T1[6], head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[7 extends T1["length"] ? 1 : 0]; 1: [head: T1[5], head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[6 extends T1["length"] ? 1 : 0]; 1: [head: T1[4], head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[5 extends T1["length"] ? 1 : 0]; 1: [head: T1[3], head: T1[2], head: T1[1], head: T1[0]]; }[4 extends T1["length"] ? 1 : 0]; 1: [head: T1[2], head: T1[1], head: T1[0]]; }[3 extends T1["length"] ? 1 : 0]; 1: [head: T1[1], head: T1[0]]; }[2 extends T1["length"] ? 1 : 0]; 1: [head: T1[0]]; }[1 extends T1["length"] ? 1 : 0]; 1: []; }[0 extends T1["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0] Reverse extends infer R ? Cast : never, T2>; type Append = ->Append : { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [(any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[9], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[8], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[7], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[10 extends ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[8], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[7], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[9 extends ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[7], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[8 extends ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[7 extends ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[6 extends ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[5 extends ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[4 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[3 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[2 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T["length"] ? 1 : 0]; 1: [T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T["length"] ? 1 : 0]; 1: [T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[1 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[10 extends T["length"] ? 1 : 0]; 1: [T[8], T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[9 extends T["length"] ? 1 : 0]; 1: [T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [E]; }[0 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends T["length"] ? 1 : 0]; 1: [T[9], T[8], T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[10 extends T["length"] ? 1 : 0]; 1: [T[8], T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[9 extends T["length"] ? 1 : 0]; 1: [T[7], T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [T[6], T[5], T[4], T[3], T[2], T[1], T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [T[5], T[4], T[3], T[2], T[1], T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [T[4], T[3], T[2], T[1], T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [T[3], T[2], T[1], T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [T[2], T[1], T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [T[1], T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0] +>Append : { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [(any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[9], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[8], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[7], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], (any[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[10 extends ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[8], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[7], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: any[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[9 extends ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[7], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: any[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[8 extends ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[6], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: any[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[7 extends ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[5], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: any[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[6 extends ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[4], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: any[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[5 extends ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[3], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[4 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[3 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[2 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T["length"] ? 1 : 0]; 1: [head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends T["length"] ? 1 : 0]; 1: [head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)[0], E]; }[1 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[10 extends T["length"] ? 1 : 0]; 1: [head: T[8], head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[9 extends T["length"] ? 1 : 0]; 1: [head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0]; 1: [E]; }[0 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends T["length"] ? 1 : 0]; 1: [head: T[9], head: T[8], head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[10 extends T["length"] ? 1 : 0]; 1: [head: T[8], head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[9 extends T["length"] ? 1 : 0]; 1: [head: T[7], head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[8 extends T["length"] ? 1 : 0]; 1: [head: T[6], head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[7 extends T["length"] ? 1 : 0]; 1: [head: T[5], head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[6 extends T["length"] ? 1 : 0]; 1: [head: T[4], head: T[3], head: T[2], head: T[1], head: T[0]]; }[5 extends T["length"] ? 1 : 0]; 1: [head: T[3], head: T[2], head: T[1], head: T[0]]; }[4 extends T["length"] ? 1 : 0]; 1: [head: T[2], head: T[1], head: T[0]]; }[3 extends T["length"] ? 1 : 0]; 1: [head: T[1], head: T[0]]; }[2 extends T["length"] ? 1 : 0]; 1: [head: T[0]]; }[1 extends T["length"] ? 1 : 0]; 1: []; }[0 extends T["length"] ? 1 : 0] extends infer R ? Cast : never)["length"] ? 1 : 0] Concat; @@ -168,7 +168,7 @@ declare namespace Curry { >Tools : any 1: Tools.Concat, T2> extends infer D ? Tools.Cast : never>; ->1 : { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [(any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[9], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[8], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[7], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[10 extends ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[8], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[7], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[9 extends ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[7], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[8 extends ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[7 extends ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[6 extends ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[5 extends ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[4 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[3 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[2 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends TN["length"] ? 1 : 0]; 1: [TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends TN["length"] ? 1 : 0]; 1: [TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[1 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[10 extends TN["length"] ? 1 : 0]; 1: [TN[8], TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[9 extends TN["length"] ? 1 : 0]; 1: [TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never; }[0 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends TN["length"] ? 1 : 0]; 1: [TN[9], TN[8], TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[10 extends TN["length"] ? 1 : 0]; 1: [TN[8], TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[9 extends TN["length"] ? 1 : 0]; 1: [TN[7], TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [TN[6], TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [TN[5], TN[4], TN[3], TN[2], TN[1], TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [TN[4], TN[3], TN[2], TN[1], TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [TN[3], TN[2], TN[1], TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [TN[2], TN[1], TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [TN[1], TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0] +>1 : { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[9], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[8], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[7], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: (any[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[10 extends ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[8], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[7], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: any[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[9 extends ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[7], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: any[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[8 extends ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[6], head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: { 0: any[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[7 extends ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[5], head: ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], head: ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: { 0: { 0: any[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[6 extends ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[4], head: ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: { 0: { 0: { 0: any[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[5 extends ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[3], head: ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: { 0: { 0: { 0: { 0: any[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[4 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[2], head: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: any[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[3 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[1], head: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[2 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends TN["length"] ? 1 : 0]; 1: [head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: [head: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[9 extends TN["length"] ? 1 : 0]; 1: [head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)[0], ...args: ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never)[number][]]; }[1 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[10 extends TN["length"] ? 1 : 0]; 1: [head: TN[8], head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[9 extends TN["length"] ? 1 : 0]; 1: [head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0]; 1: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>>; }[10 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>>; }[9 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>>; }[8 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>>; }[7 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>>; }[6 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>>; }[5 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>>; }[4 extends I["length"] ? 1 : 0]; 1: Tools.Tail>>; }[3 extends I["length"] ? 1 : 0]; 1: Tools.Tail>; }[2 extends I["length"] ? 1 : 0]; 1: Tools.Tail; }[1 extends I["length"] ? 1 : 0]; 1: T2; }[0 extends I["length"] ? 1 : 0] extends infer D ? Tools.Cast : never; }[0 extends ({ 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: { 0: any[11 extends TN["length"] ? 1 : 0]; 1: [head: TN[9], head: TN[8], head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[10 extends TN["length"] ? 1 : 0]; 1: [head: TN[8], head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[9 extends TN["length"] ? 1 : 0]; 1: [head: TN[7], head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[8 extends TN["length"] ? 1 : 0]; 1: [head: TN[6], head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[7 extends TN["length"] ? 1 : 0]; 1: [head: TN[5], head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[6 extends TN["length"] ? 1 : 0]; 1: [head: TN[4], head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[5 extends TN["length"] ? 1 : 0]; 1: [head: TN[3], head: TN[2], head: TN[1], head: TN[0]]; }[4 extends TN["length"] ? 1 : 0]; 1: [head: TN[2], head: TN[1], head: TN[0]]; }[3 extends TN["length"] ? 1 : 0]; 1: [head: TN[1], head: TN[0]]; }[2 extends TN["length"] ? 1 : 0]; 1: [head: TN[0]]; }[1 extends TN["length"] ? 1 : 0]; 1: []; }[0 extends TN["length"] ? 1 : 0] extends infer R ? Tools.Cast : never)["length"] ? 1 : 0] >Tools : any >Tools : any >Tools : any diff --git a/tests/baselines/reference/restTuplesFromContextualTypes.errors.txt b/tests/baselines/reference/restTuplesFromContextualTypes.errors.txt index 5f2c299735b0b..5c3d13b87e468 100644 --- a/tests/baselines/reference/restTuplesFromContextualTypes.errors.txt +++ b/tests/baselines/reference/restTuplesFromContextualTypes.errors.txt @@ -1,7 +1,7 @@ tests/cases/conformance/types/rest/restTuplesFromContextualTypes.ts(56,7): error TS2345: Argument of type '(a: number, b: T[0], ...x: T[number][]) => void' is not assignable to parameter of type '(x: number, ...args: T) => void'. Types of parameters 'b' and 'args' are incompatible. - Type 'T' is not assignable to type '[T[0], ...T[number][]]'. - Property '0' is missing in type 'any[]' but required in type '[T[0], ...T[number][]]'. + Type 'T' is not assignable to type '[b: T[0], ...x: T[number][]]'. + Property '0' is missing in type 'any[]' but required in type '[b: T[0], ...x: T[number][]]'. ==== tests/cases/conformance/types/rest/restTuplesFromContextualTypes.ts (1 errors) ==== @@ -64,8 +64,8 @@ tests/cases/conformance/types/rest/restTuplesFromContextualTypes.ts(56,7): error ~~~~~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '(a: number, b: T[0], ...x: T[number][]) => void' is not assignable to parameter of type '(x: number, ...args: T) => void'. !!! error TS2345: Types of parameters 'b' and 'args' are incompatible. -!!! error TS2345: Type 'T' is not assignable to type '[T[0], ...T[number][]]'. -!!! error TS2345: Property '0' is missing in type 'any[]' but required in type '[T[0], ...T[number][]]'. +!!! error TS2345: Type 'T' is not assignable to type '[b: T[0], ...x: T[number][]]'. +!!! error TS2345: Property '0' is missing in type 'any[]' but required in type '[b: T[0], ...x: T[number][]]'. } declare function f5(f: (...args: T) => U): (...args: T) => U; diff --git a/tests/baselines/reference/restTuplesFromContextualTypes.types b/tests/baselines/reference/restTuplesFromContextualTypes.types index 6dd2a6d90cb68..b43299fc6dd5b 100644 --- a/tests/baselines/reference/restTuplesFromContextualTypes.types +++ b/tests/baselines/reference/restTuplesFromContextualTypes.types @@ -67,20 +67,20 @@ f1((a, b, c) => {}) f1((...x) => {}) >f1((...x) => {}) : void >f1 : (cb: (args_0: number, args_1: boolean, args_2: string) => void) => void ->(...x) => {} : (args_0: number, args_1: boolean, args_2: string) => void +>(...x) => {} : (x_0: number, x_1: boolean, x_2: string) => void >x : [number, boolean, string] f1((a, ...x) => {}) >f1((a, ...x) => {}) : void >f1 : (cb: (args_0: number, args_1: boolean, args_2: string) => void) => void ->(a, ...x) => {} : (a: number, args_1: boolean, args_2: string) => void +>(a, ...x) => {} : (a: number, x_0: boolean, x_1: string) => void >a : number >x : [boolean, string] f1((a, b, ...x) => {}) >f1((a, b, ...x) => {}) : void >f1 : (cb: (args_0: number, args_1: boolean, args_2: string) => void) => void ->(a, b, ...x) => {} : (a: number, b: boolean, args_2: string) => void +>(a, b, ...x) => {} : (a: number, b: boolean, x_0: string) => void >a : number >b : boolean >x : [string] @@ -162,13 +162,13 @@ f2((a, b, c) => {}) f2((...x) => {}) >f2((...x) => {}) : void >f2 : (cb: (args_0: number, args_1: boolean, ...args_2: string[]) => void) => void ->(...x) => {} : (args_0: number, args_1: boolean, ...args_2: string[]) => void +>(...x) => {} : (x_0: number, x_1: boolean, ...x_2: string[]) => void >x : [number, boolean, ...string[]] f2((a, ...x) => {}) >f2((a, ...x) => {}) : void >f2 : (cb: (args_0: number, args_1: boolean, ...args_2: string[]) => void) => void ->(a, ...x) => {} : (a: number, args_1: boolean, ...args_2: string[]) => void +>(a, ...x) => {} : (a: number, x_0: boolean, ...x_1: string[]) => void >a : number >x : [boolean, ...string[]] @@ -263,13 +263,13 @@ f3((a, b, c) => {}) f3((...x) => {}) >f3((...x) => {}) : void >f3 : (cb: (x: number, args_0: boolean, ...args_1: string[]) => void) => void ->(...x) => {} : (x: number, args_0: boolean, ...args_1: string[]) => void +>(...x) => {} : (x_0: number, x_1: boolean, ...x_2: string[]) => void >x : [number, boolean, ...string[]] f3((a, ...x) => {}) >f3((a, ...x) => {}) : void >f3 : (cb: (x: number, args_0: boolean, ...args_1: string[]) => void) => void ->(a, ...x) => {} : (a: number, args_0: boolean, ...args_1: string[]) => void +>(a, ...x) => {} : (a: number, x_0: boolean, ...x_1: string[]) => void >a : number >x : [boolean, ...string[]] @@ -333,7 +333,7 @@ function f4(t: T) { >f((...x) => {}) : void >f : (cb: (x: number, ...args: T) => void) => void >(...x) => {} : (x: number, ...args: T[number][]) => void ->x : [number, ...T[number][]] +>x : [x: number, ...args: T[number][]] f((a, ...x) => {}); >f((a, ...x) => {}) : void @@ -496,7 +496,7 @@ take(function(...rest){}); >take(function(...rest){}) : void >take : (cb: (a: number, b: string) => void) => void >function(...rest){} : (a: number, b: string) => void ->rest : [number, string] +>rest : [a: number, b: string] // Repro from #29833 diff --git a/tests/baselines/reference/strictBindCallApply1.errors.txt b/tests/baselines/reference/strictBindCallApply1.errors.txt index cd30931bcfe4a..ee1718db34c9e 100644 --- a/tests/baselines/reference/strictBindCallApply1.errors.txt +++ b/tests/baselines/reference/strictBindCallApply1.errors.txt @@ -9,10 +9,10 @@ tests/cases/conformance/functions/strictBindCallApply1.ts(11,11): error TS2769: tests/cases/conformance/functions/strictBindCallApply1.ts(17,15): error TS2554: Expected 3 arguments, but got 2. tests/cases/conformance/functions/strictBindCallApply1.ts(18,35): error TS2345: Argument of type '20' is not assignable to parameter of type 'string'. tests/cases/conformance/functions/strictBindCallApply1.ts(19,44): error TS2554: Expected 3 arguments, but got 4. -tests/cases/conformance/functions/strictBindCallApply1.ts(22,32): error TS2345: Argument of type '[number]' is not assignable to parameter of type '[number, string]'. - Property '1' is missing in type '[number]' but required in type '[number, string]'. +tests/cases/conformance/functions/strictBindCallApply1.ts(22,32): error TS2345: Argument of type '[number]' is not assignable to parameter of type '[a: number, b: string]'. + Property '1' is missing in type '[number]' but required in type '[a: number, b: string]'. tests/cases/conformance/functions/strictBindCallApply1.ts(23,37): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/functions/strictBindCallApply1.ts(24,32): error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[number, string]'. +tests/cases/conformance/functions/strictBindCallApply1.ts(24,32): error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[a: number, b: string]'. Types of property 'length' are incompatible. Type '3' is not assignable to type '2'. tests/cases/conformance/functions/strictBindCallApply1.ts(41,11): error TS2769: No overload matches this call. @@ -35,9 +35,12 @@ tests/cases/conformance/functions/strictBindCallApply1.ts(48,17): error TS2554: tests/cases/conformance/functions/strictBindCallApply1.ts(49,29): error TS2345: Argument of type '20' is not assignable to parameter of type 'string'. tests/cases/conformance/functions/strictBindCallApply1.ts(50,38): error TS2554: Expected 3 arguments, but got 4. tests/cases/conformance/functions/strictBindCallApply1.ts(51,22): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'C'. -tests/cases/conformance/functions/strictBindCallApply1.ts(54,26): error TS2345: Argument of type '[number]' is not assignable to parameter of type '[number, string]'. +tests/cases/conformance/functions/strictBindCallApply1.ts(54,26): error TS2345: Argument of type '[number]' is not assignable to parameter of type '[a: number, b: string]'. + Property '1' is missing in type '[number]' but required in type '[a: number, b: string]'. tests/cases/conformance/functions/strictBindCallApply1.ts(55,31): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/functions/strictBindCallApply1.ts(56,26): error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[number, string]'. +tests/cases/conformance/functions/strictBindCallApply1.ts(56,26): error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[a: number, b: string]'. + Types of property 'length' are incompatible. + Type '3' is not assignable to type '2'. tests/cases/conformance/functions/strictBindCallApply1.ts(57,23): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'C'. tests/cases/conformance/functions/strictBindCallApply1.ts(62,11): error TS2769: No overload matches this call. Overload 1 of 6, '(this: new (arg0: 10, arg1: string) => C, thisArg: any, arg0: 10, arg1: string): new () => C', gave the following error. @@ -50,9 +53,12 @@ tests/cases/conformance/functions/strictBindCallApply1.ts(62,11): error TS2769: tests/cases/conformance/functions/strictBindCallApply1.ts(65,3): error TS2554: Expected 3 arguments, but got 2. tests/cases/conformance/functions/strictBindCallApply1.ts(66,15): error TS2345: Argument of type '20' is not assignable to parameter of type 'string'. tests/cases/conformance/functions/strictBindCallApply1.ts(67,24): error TS2554: Expected 3 arguments, but got 4. -tests/cases/conformance/functions/strictBindCallApply1.ts(70,12): error TS2345: Argument of type '[number]' is not assignable to parameter of type '[number, string]'. +tests/cases/conformance/functions/strictBindCallApply1.ts(70,12): error TS2345: Argument of type '[number]' is not assignable to parameter of type '[a: number, b: string]'. + Property '1' is missing in type '[number]' but required in type '[a: number, b: string]'. tests/cases/conformance/functions/strictBindCallApply1.ts(71,17): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/functions/strictBindCallApply1.ts(72,12): error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[number, string]'. +tests/cases/conformance/functions/strictBindCallApply1.ts(72,12): error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[a: number, b: string]'. + Types of property 'length' are incompatible. + Type '3' is not assignable to type '2'. ==== tests/cases/conformance/functions/strictBindCallApply1.ts (24 errors) ==== @@ -94,14 +100,14 @@ tests/cases/conformance/functions/strictBindCallApply1.ts(72,12): error TS2345: let a00 = foo.apply(undefined, [10, "hello"]); let a01 = foo.apply(undefined, [10]); // Error ~~~~ -!!! error TS2345: Argument of type '[number]' is not assignable to parameter of type '[number, string]'. -!!! error TS2345: Property '1' is missing in type '[number]' but required in type '[number, string]'. +!!! error TS2345: Argument of type '[number]' is not assignable to parameter of type '[a: number, b: string]'. +!!! error TS2345: Property '1' is missing in type '[number]' but required in type '[a: number, b: string]'. let a02 = foo.apply(undefined, [10, 20]); // Error ~~ !!! error TS2322: Type 'number' is not assignable to type 'string'. let a03 = foo.apply(undefined, [10, "hello", 30]); // Error ~~~~~~~~~~~~~~~~~ -!!! error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[number, string]'. +!!! error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[a: number, b: string]'. !!! error TS2345: Types of property 'length' are incompatible. !!! error TS2345: Type '3' is not assignable to type '2'. @@ -161,13 +167,16 @@ tests/cases/conformance/functions/strictBindCallApply1.ts(72,12): error TS2345: let a10 = c.foo.apply(c, [10, "hello"]); let a11 = c.foo.apply(c, [10]); // Error ~~~~ -!!! error TS2345: Argument of type '[number]' is not assignable to parameter of type '[number, string]'. +!!! error TS2345: Argument of type '[number]' is not assignable to parameter of type '[a: number, b: string]'. +!!! error TS2345: Property '1' is missing in type '[number]' but required in type '[a: number, b: string]'. let a12 = c.foo.apply(c, [10, 20]); // Error ~~ !!! error TS2322: Type 'number' is not assignable to type 'string'. let a13 = c.foo.apply(c, [10, "hello", 30]); // Error ~~~~~~~~~~~~~~~~~ -!!! error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[number, string]'. +!!! error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[a: number, b: string]'. +!!! error TS2345: Types of property 'length' are incompatible. +!!! error TS2345: Type '3' is not assignable to type '2'. let a14 = c.foo.apply(undefined, [10, "hello"]); // Error ~~~~~~~~~ !!! error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'C'. @@ -200,11 +209,14 @@ tests/cases/conformance/functions/strictBindCallApply1.ts(72,12): error TS2345: C.apply(c, [10, "hello"]); C.apply(c, [10]); // Error ~~~~ -!!! error TS2345: Argument of type '[number]' is not assignable to parameter of type '[number, string]'. +!!! error TS2345: Argument of type '[number]' is not assignable to parameter of type '[a: number, b: string]'. +!!! error TS2345: Property '1' is missing in type '[number]' but required in type '[a: number, b: string]'. C.apply(c, [10, 20]); // Error ~~ !!! error TS2322: Type 'number' is not assignable to type 'string'. C.apply(c, [10, "hello", 30]); // Error ~~~~~~~~~~~~~~~~~ -!!! error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[number, string]'. +!!! error TS2345: Argument of type '[number, string, number]' is not assignable to parameter of type '[a: number, b: string]'. +!!! error TS2345: Types of property 'length' are incompatible. +!!! error TS2345: Type '3' is not assignable to type '2'. \ No newline at end of file diff --git a/tests/cases/conformance/types/tuple/named/namedTupleMembers.ts b/tests/cases/conformance/types/tuple/named/namedTupleMembers.ts new file mode 100644 index 0000000000000..9846c4f5b0f98 --- /dev/null +++ b/tests/cases/conformance/types/tuple/named/namedTupleMembers.ts @@ -0,0 +1,79 @@ +// @declaration: true + +export type Segment = [length: number, count: number]; + +export type SegmentAnnotated = [ + /** + * Size of message buffer segment handles + */ + length: number, + /** + * Number of segments handled at once + */ + count: number +]; + +declare var a: Segment; +declare var b: SegmentAnnotated; +declare var c: [number, number]; +declare var d: [a: number, b: number]; + +a = b; +a = c; +a = d; + +b = a; +b = c; +b = d; + +c = a; +c = b; +c = d; + +d = a; +d = b; +d = c; + +export type WithOptAndRest = [first: number, second?: number, ...rest: string[]]; + +export type Func = (...x: T) => void; + +export const func = null as any as Func; + +export function useState(initial: T): [value: T, setter: (T) => void] { + return null as any; +} + + +export type Iter = Func<[step: number, iterations: number]>; + +export function readSegment([length, count]: [number, number]) {} + +// documenting binding pattern behavior (currently does _not_ generate tuple names) +export const val = null as any as Parameters[0]; + +export type RecursiveTupleA = [initial: string, next: RecursiveTupleA]; + +export type RecursiveTupleB = [first: string, ptr: RecursiveTupleB]; + +declare var q: RecursiveTupleA; +declare var r: RecursiveTupleB; + +q = r; +r = q; + +export type RecusiveRest = [first: string, ...rest: RecusiveRest[]]; +export type RecusiveRest2 = [string, ...RecusiveRest2[]]; + +declare var x: RecusiveRest; +declare var y: RecusiveRest2; + +x = y; +y = x; + +declare function f(...x: T): T; +declare function g(elem: object, index: number): object; +declare function getArgsForInjection any>(x: T): Parameters; + +export const argumentsOfGAsFirstArgument = f(getArgsForInjection(g)); // one tuple with captures arguments as first member +export const argumentsOfG = f(...getArgsForInjection(g)); // captured arguments list re-spread diff --git a/tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts b/tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts new file mode 100644 index 0000000000000..75eb3d3deca24 --- /dev/null +++ b/tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts @@ -0,0 +1,20 @@ +// @declaration: true + +export type Segment1 = [length: number, number]; // partially named, disallowed + +export type List = [item: any, ...any]; // partially named, disallowed + +export type Pair = [item: any, any?]; // partially named, disallowed + +export type Opt = [element: string?]; // question mark on element disallowed + +export type Trailing = [first: string, rest: ...string[]]; // dots on element disallowed + +export type OptTrailing = [first: string, rest: ...string[]?]; // dots+question on element disallowed + +export type OptRest = [first: string, ...rest?: string[]]; // rest+optional disallowed + +export type NonArrayRest = [first: string, ...rest: number]; // non-arraylike rest, disallowed + +export type RecusiveRestUnlabeled = [string, ...RecusiveRestUnlabeled]; +export type RecusiveRest = [first: string, ...rest: RecusiveRest]; // marked as incorrect, same as above diff --git a/tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax1.ts b/tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax1.ts new file mode 100644 index 0000000000000..08c8234e634b3 --- /dev/null +++ b/tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax1.ts @@ -0,0 +1,10 @@ +/// + +////type Tup = [first: string, elem: ...any[]]; + +verify.codeFix({ + description: "Move labeled tuple element modifiers to labels", + index: 0, + newFileContent: + `type Tup = [first: string, ...elem: any[]];` +}); \ No newline at end of file diff --git a/tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax2.ts b/tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax2.ts new file mode 100644 index 0000000000000..9a7f7590d9666 --- /dev/null +++ b/tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax2.ts @@ -0,0 +1,10 @@ +/// + +////type Tup = [first: string, elem: any[]?]; + +verify.codeFix({ + description: "Move labeled tuple element modifiers to labels", + index: 0, + newFileContent: + `type Tup = [first: string, elem?: any[]];` +}); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsElementAccessNumeric.ts b/tests/cases/fourslash/completionsElementAccessNumeric.ts new file mode 100644 index 0000000000000..dbb330a7ae91c --- /dev/null +++ b/tests/cases/fourslash/completionsElementAccessNumeric.ts @@ -0,0 +1,30 @@ +/// + +// @target: esnext + +////type Tup = [ +//// /** +//// * The first label +//// */ +//// lbl1: number, +//// /** +//// * The second label +//// */ +//// lbl2: number +////]; +////declare var x: Tup; +////x[|./**/|] + +const replacementSpan = test.ranges()[0]; +verify.completions( + { + marker: "", + includes: [ + {name: "0", insertText: "[0]", replacementSpan, documentation: "The first label", text: "(property) 0: number (lbl1)" }, + {name: "1", insertText: "[1]", replacementSpan, documentation: "The second label", text: "(property) 1: number (lbl2)" }, + ], + preferences: { + includeInsertTextCompletions: true, + }, + }, +); diff --git a/tests/cases/fourslash/contextuallyTypedParameters.ts b/tests/cases/fourslash/contextuallyTypedParameters.ts index f600180c08725..b19ec282eb64d 100644 --- a/tests/cases/fourslash/contextuallyTypedParameters.ts +++ b/tests/cases/fourslash/contextuallyTypedParameters.ts @@ -40,19 +40,19 @@ verify.quickInfos({ 10: "(parameter) a: number", - 11: "(parameter) args: [string, boolean]", + 11: "(parameter) args: [y: string, z: boolean]", 20: "(parameter) a: number", 21: "(parameter) b: string", - 22: "(parameter) args: [boolean]", + 22: "(parameter) args: [z: boolean]", 30: "(parameter) a: number", 31: "(parameter) b: string", 32: "(parameter) c: boolean", 33: "(parameter) args: []", 40: "(parameter) a: number", - 41: "(parameter) args: [string, boolean]", + 41: "(parameter) args: [y: string, z: boolean]", 50: "(parameter) a: number", 51: "(parameter) b: string", - 52: "(parameter) args: [boolean]", + 52: "(parameter) args: [z: boolean]", 60: "(parameter) a: number", 61: "(parameter) b: string", 62: "(parameter) c: boolean", diff --git a/tests/cases/fourslash/namedTupleMembers.ts b/tests/cases/fourslash/namedTupleMembers.ts new file mode 100644 index 0000000000000..034570e715ffe --- /dev/null +++ b/tests/cases/fourslash/namedTupleMembers.ts @@ -0,0 +1,5 @@ +/// + +////export type /*1*/Segment = [length: number, count: number]; + +verify.quickInfoAt("1", "type Segment = [length: number, count: number]"); \ No newline at end of file diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature1.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature1.ts new file mode 100644 index 0000000000000..b2be8adb43d44 --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature1.ts @@ -0,0 +1,14 @@ +/// + +/////*a*/declare function foo(): void; +////declare function foo(a: string): void; +////declare function foo(a: number, b: number): void; +////declare function foo(...rest: symbol[]): void;/*b*/ + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `declare function foo(...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]): void;`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature2.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature2.ts new file mode 100644 index 0000000000000..8259dfb79b89a --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature2.ts @@ -0,0 +1,49 @@ +/// + +/////*a*/declare function foo(): void; +/////** +//// * @param a a string param doc +//// */ +////declare function foo(a: string): void; +/////** +//// * @param a a number param doc +//// * @param b b number param doc +//// */ +////declare function foo(a: number, b: number): void; +/////** +//// * @param rest rest param doc +//// */ +////declare function foo(...rest: symbol[]): void;/*b*/ + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, +// we don't delete the param comment on the signature we update because deleting *part* of a comment is... hard +// and we definitely don't want to delete the whole comment. This is probably a good argument for why jsdoc should +// really be uniformly handled as AST nodes, and transformed as such :( +newContent: `/** + * @param rest rest param doc + */ +declare function foo(...args: [] | [ + /** + * a string param doc + */ + a: string +] | [ + /** + * a number param doc + */ + a: number, + /** + * b number param doc + */ + b: number +] | [ + /** + * rest param doc + */ + ...rest: symbol[] +]): void;`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature3.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature3.ts new file mode 100644 index 0000000000000..1de08f5852e15 --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature3.ts @@ -0,0 +1,19 @@ +/// + +/////*a*/function foo(): void; +////function foo(a: string): void; +////function foo(a: number, b: number): void; +////function foo(...rest: symbol[]): void;/*b*/ +////function foo(...args: any[]): void { +//// // body +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `function foo(...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]): void { + // body +}`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature4.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature4.ts new file mode 100644 index 0000000000000..d42130fc0f6b6 --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature4.ts @@ -0,0 +1,23 @@ +/// + +////class A { +//// /*a*/foo(): void; +//// foo(a: string): void; +//// foo(a: number, b: number): void; +//// foo(...rest: symbol[]): void;/*b*/ +//// foo(...args: any[]): void { +//// // body +//// } +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `class A { + foo(...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]): void { + // body + } +}`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature5.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature5.ts new file mode 100644 index 0000000000000..d8aabb038fd34 --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature5.ts @@ -0,0 +1,23 @@ +/// + +////class A { +//// /*a*/constructor(); +//// constructor(a: string); +//// constructor(a: number, b: number); +//// constructor(...rest: symbol[]);/*b*/ +//// constructor(...args: any[]) { +//// // body +//// } +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `class A { + constructor(...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]) { + // body + } +}`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature6.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature6.ts new file mode 100644 index 0000000000000..0c3c0143f26ca --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature6.ts @@ -0,0 +1,18 @@ +/// + +////interface A { +//// /*a*/(): void; +//// (a: string): void; +//// (a: number, b: number): void; +//// (...rest: symbol[]): void;/*b*/ +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `interface A { + (...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]): void; +}`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature7.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature7.ts new file mode 100644 index 0000000000000..90a638be021fe --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature7.ts @@ -0,0 +1,18 @@ +/// + +////interface A { +//// /*a*/new (): void; +//// new (a: string): void; +//// new (a: number, b: number): void; +//// new (...rest: symbol[]): void;/*b*/ +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `interface A { + new(...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]): void; +}`, +}); diff --git a/tests/cases/fourslash/refactorOverloadListToSingleSignature8.ts b/tests/cases/fourslash/refactorOverloadListToSingleSignature8.ts new file mode 100644 index 0000000000000..a540e8544a5e6 --- /dev/null +++ b/tests/cases/fourslash/refactorOverloadListToSingleSignature8.ts @@ -0,0 +1,18 @@ +/// + +////interface A { +//// /*a*/foo(): void; +//// foo(a: string): void; +//// foo(a: number, b: number): void; +//// foo(...rest: symbol[]): void;/*b*/ +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Convert overload list to single signature", + actionName: "Convert overload list to single signature", + actionDescription: ts.Diagnostics.Convert_overload_list_to_single_signature.message, + newContent: `interface A { + foo(...args: [] | [a: string] | [a: number, b: number] | [...rest: symbol[]]): void; +}`, +}); diff --git a/tests/cases/fourslash/restArgType.ts b/tests/cases/fourslash/restArgType.ts index 69601c14ccfb2..057786489bf55 100644 --- a/tests/cases/fourslash/restArgType.ts +++ b/tests/cases/fourslash/restArgType.ts @@ -38,12 +38,12 @@ verify.quickInfos({ 4: "(parameter) y1: string[]", 5: "(parameter) y2: string", - t1: "(parameter) f1: [string, string]", + t1: "(parameter) f1: [a1: string, a2: string]", - t2: "(parameter) f1: [string, ...string[]]", + t2: "(parameter) f1: [a1: string, ...a2: string[]]", t31: "(parameter) f1: number", - t32: "(parameter) f2: [boolean, ...string[]]", + t32: "(parameter) f2: [a2: boolean, ...c: string[]]", t4: "(parameter) f1: string[]", t5: "(parameter) f1: string", diff --git a/tests/cases/fourslash/signatureHelpExpandedRestTuples.ts b/tests/cases/fourslash/signatureHelpExpandedRestTuples.ts new file mode 100644 index 0000000000000..2808a8eb88e14 --- /dev/null +++ b/tests/cases/fourslash/signatureHelpExpandedRestTuples.ts @@ -0,0 +1,36 @@ +/// + +////export function complex(item: string, another: string, ...rest: [] | [settings: object, errorHandler: (err: Error) => void] | [errorHandler: (err: Error) => void, ...mixins: object[]]) { +//// +////} +//// +////complex(/*1*/); +////complex("ok", "ok", /*2*/); +////complex("ok", "ok", e => void e, {}, /*3*/); + +verify.signatureHelp( + { + marker: "1", + text: "complex(item: string, another: string): void", + overloadsCount: 3, + parameterCount: 2, + parameterName: "item", + parameterSpan: "item: string", + isVariadic: false, + }, + { + marker: "2", + text: "complex(item: string, another: string, settings: object, errorHandler: (err: Error) => void): void", + overloadsCount: 3, + parameterCount: 4, + parameterName: "settings", + parameterSpan: "settings: object", + isVariadic: false, + }, + { + marker: "3", + text: "complex(item: string, another: string, errorHandler: (err: Error) => void, ...mixins: object[]): void", + overloadsCount: 3, + isVariadic: true, + }, +);